@cullet/erp-core 1.4.0 → 2.0.0

package/dist/uuid-identifier.d.ts

@@ -49,7 +49,8 @@ declare abstract class Entity<TIdentifier> {
    * Declared `protected` because entities are reconstituted through a
    * subclass factory, never instantiated directly by application code.
    *
-   * @throws {InvariantViolationException} When `updatedAt` is earlier than `createdAt`.
+   * @throws {InvariantViolationException} When `id` is absent, or when
+   *   `updatedAt` is earlier than `createdAt`.
    */
   protected constructor(state: EntityState<TIdentifier>);
   /** The entity's stable identity — the basis for equality between entities. */
@@ -86,13 +87,29 @@ declare abstract class Entity<TIdentifier> {
    * 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.
+   * `updatedAt` is monotonic: each call must be at or after the current
+   * `updatedAt` (equal is fine — two mutations can share a millisecond).
+   * Without this, the version counter would advance while the timestamp
+   * walked backwards, corrupting any audit trail or ordering that reads
+   * `updatedAt`. A caller replaying out-of-order events must sort them first.
+   *
+   * @param updatedAt - The modification instant; defaults to now.
    * @returns The new aggregate version after the increment.
-   * @throws {InvariantViolationException} When `updatedAt` is earlier than `createdAt`.
+   * @throws {InvariantViolationException} When `updatedAt` is earlier than
+   *   the current `updatedAt`.
    */
   protected markAsModified(updatedAt?: Date): number;
+  /**
+   * Identity-based equality — the semantics that define an entity. Two
+   * entities are equal when they are the same concrete class and their ids
+   * match, regardless of any other field.
+   *
+   * The class check keeps a `CustomerId`-bearing entity from equalling an
+   * unrelated entity that happens to reuse the same raw id. Value-object ids
+   * are compared through their own `equals`, so two independently
+   * reconstituted id instances still match; primitive ids use `===`.
+   */
+  equals(other: Entity<TIdentifier> | null | undefined): boolean;
 }
 //#endregion
 //#region src/core/domain/uuid-identifier.d.ts
@@ -137,8 +154,10 @@ declare abstract class UuidIdentifier<TBrand extends string = string> extends Va
   /** The wrapped UUID string — convenient for logging and interpolation. */
   toString(): string;
   /**
-   * Whether `candidate` is a canonical UUID (versions 1–5). The single source
-   * of truth for the format; concrete identifiers call this from `create`.
+   * Whether `candidate` is a canonical UUID (versions 1–8, including the
+   * time-ordered v7; nil and max UUIDs are rejected as sentinels). The single
+   * source of truth for the format — see `shared/uuid.ts`; concrete
+   * identifiers call this from `create`.
    */
   static isValid(candidate: string): boolean;
 }

package/dist/uuid-identifier.js

@@ -1,11 +1,136 @@
+import { t as InvariantViolationException } from "./invariant-violation-exception.js";
+import { n as cloneDate, t as assertValidDate } from "./temporal-guards.js";
+import { i as version } from "./immutable.js";
+import { t as __decorate } from "./decorate.js";
+import { t as UUID_PATTERN } from "./uuid.js";
+import { t as assertValidAggregateVersion } from "./aggregate-version.js";
 import { t as ValueObject } from "./value-object.js";
-//#region src/core/domain/uuid-identifier.ts
+//#region src/core/domain/entity.ts
 /**
-* Canonical RFC-4122 UUID (versions 1–5), matched case-insensitively. Declared
-* once here so the dozens of typed identifiers a domain accumulates never have
-* to re-state the pattern.
+* 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).
 */
-const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+let Entity = class Entity {
+	/**
+	* 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 `id` is absent, or when
+	*   `updatedAt` is earlier than `createdAt`.
+	*/
+	constructor(state) {
+		if (state.id == null) throw new InvariantViolationException("id is required: an entity cannot exist without an identity");
+		assertValidDate("createdAt", state.createdAt);
+		assertValidDate("updatedAt", state.updatedAt);
+		assertValidAggregateVersion(state.aggregateVersion);
+		if (state.updatedAt.getTime() < state.createdAt.getTime()) throw new InvariantViolationException("updatedAt cannot be earlier than createdAt");
+		this._id = state.id;
+		this._createdAt = cloneDate(state.createdAt);
+		this._updatedAt = 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 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 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 this.constructor.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.
+	*
+	* `updatedAt` is monotonic: each call must be at or after the current
+	* `updatedAt` (equal is fine — two mutations can share a millisecond).
+	* Without this, the version counter would advance while the timestamp
+	* walked backwards, corrupting any audit trail or ordering that reads
+	* `updatedAt`. A caller replaying out-of-order events must sort them first.
+	*
+	* @param updatedAt - The modification instant; defaults to now.
+	* @returns The new aggregate version after the increment.
+	* @throws {InvariantViolationException} When `updatedAt` is earlier than
+	*   the current `updatedAt`.
+	*/
+	markAsModified(updatedAt = /* @__PURE__ */ new Date()) {
+		assertValidDate("updatedAt", updatedAt);
+		if (updatedAt.getTime() < this._updatedAt.getTime()) throw new InvariantViolationException("updatedAt cannot move backwards: it must be at or after the current updatedAt");
+		this._updatedAt = cloneDate(updatedAt);
+		this._aggregateVersion += 1;
+		return this._aggregateVersion;
+	}
+	/**
+	* Identity-based equality — the semantics that define an entity. Two
+	* entities are equal when they are the same concrete class and their ids
+	* match, regardless of any other field.
+	*
+	* The class check keeps a `CustomerId`-bearing entity from equalling an
+	* unrelated entity that happens to reuse the same raw id. Value-object ids
+	* are compared through their own `equals`, so two independently
+	* reconstituted id instances still match; primitive ids use `===`.
+	*/
+	equals(other) {
+		if (other == null) return false;
+		if (other === this) return true;
+		if (other.constructor !== this.constructor) return false;
+		const id = this._id;
+		if (id instanceof ValueObject) return id.equals(other._id);
+		return this._id === other._id;
+	}
+};
+Entity = __decorate([version("1.0")], Entity);
+//#endregion
+//#region src/core/domain/uuid-identifier.ts
 /**
 * Base class for UUID-backed identity value objects.
 *
@@ -47,14 +172,16 @@ var UuidIdentifier = class extends ValueObject {
 		return this.value;
 	}
 	/**
-	* Whether `candidate` is a canonical UUID (versions 1–5). The single source
-	* of truth for the format; concrete identifiers call this from `create`.
+	* Whether `candidate` is a canonical UUID (versions 1–8, including the
+	* time-ordered v7; nil and max UUIDs are rejected as sentinels). The single
+	* source of truth for the format — see `shared/uuid.ts`; concrete
+	* identifiers call this from `create`.
 	*/
 	static isValid(candidate) {
 		return UUID_PATTERN.test(candidate);
 	}
 };
 //#endregion
-export { UuidIdentifier as t };
+export { Entity as n, UuidIdentifier as t };
 
 //# sourceMappingURL=uuid-identifier.js.map

package/dist/uuid-identifier.js.map

@@ -1 +1 @@
-{"version":3,"file":"uuid-identifier.js","names":[],"sources":["../src/core/domain/uuid-identifier.ts"],"sourcesContent":["import { ValueObject } from \"./value-object.js\";\n\n/**\n * Canonical RFC-4122 UUID (versions 1–5), matched case-insensitively. Declared\n * once here so the dozens of typed identifiers a domain accumulates never have\n * to re-state the pattern.\n */\nconst UUID_PATTERN =\n    /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;\n\n/**\n * Base class for UUID-backed identity value objects.\n *\n * A domain typically has many of these — `OrderId`, `CustomerId`, `InvoiceId` —\n * all wrapping the same `string` shape. Two problems follow: the UUID format\n * check gets copy-pasted into every one, and because the wrapped shape is\n * identical, TypeScript's structural typing would happily accept an `OrderId`\n * where a `CustomerId` is expected. `UuidIdentifier` solves both: the format\n * lives here once ({@link isValid}), and the `TBrand` phantom tag makes each\n * subtype nominally distinct so the ids cannot be swapped for one another.\n *\n * It deliberately does not impose a factory. Identifiers vary in how they\n * report an invalid value (their own exception type, their own message), so a\n * concrete id adds a validating `create` that calls {@link isValid} plus a\n * `reconstitute` that trusts an already-persisted value:\n *\n * ```ts\n * class OrderId extends UuidIdentifier<\"OrderId\"> {\n *   private constructor(value: string) { super(value); }\n *   static create(raw: string): OrderId {\n *     if (!UuidIdentifier.isValid(raw)) throw new InvalidOrderIdError(raw);\n *     return new OrderId(raw);\n *   }\n *   static reconstitute(value: string): OrderId { return new OrderId(value); }\n * }\n * ```\n *\n * @typeParam TBrand - A unique string literal that nominally tags the subtype.\n */\nabstract class UuidIdentifier<\n    TBrand extends string = string,\n> extends ValueObject<string, string> {\n    /**\n     * Phantom brand. Never assigned at runtime (`declare`), it exists only so\n     * two identifiers with different brands are not interchangeable at the type\n     * level despite sharing the same `string` value.\n     */\n    protected declare readonly __brand: TBrand;\n\n    protected constructor(value: string) {\n        super(value);\n    }\n\n    public toPrimitive(): string {\n        return this.value;\n    }\n\n    /** The wrapped UUID string — convenient for logging and interpolation. */\n    public toString(): string {\n        return this.value;\n    }\n\n    /**\n     * Whether `candidate` is a canonical UUID (versions 1–5). The single source\n     * of truth for the format; concrete identifiers call this from `create`.\n     */\n    public static isValid(candidate: string): boolean {\n        return UUID_PATTERN.test(candidate);\n    }\n}\n\nexport { UuidIdentifier };\n"],"mappings":";;;;;;;AAOA,MAAM,eACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BJ,IAAe,iBAAf,cAEU,YAA4B;CAQlC,YAAsB,OAAe;EACjC,MAAM,KAAK;CACf;CAEA,cAA6B;EACzB,OAAO,KAAK;CAChB;;CAGA,WAA0B;EACtB,OAAO,KAAK;CAChB;;;;;CAMA,OAAc,QAAQ,WAA4B;EAC9C,OAAO,aAAa,KAAK,SAAS;CACtC;AACJ"}
+{"version":3,"file":"uuid-identifier.js","names":[],"sources":["../src/core/domain/entity.ts","../src/core/domain/uuid-identifier.ts"],"sourcesContent":["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\nimport { ValueObject } from \"./value-object.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 `id` is absent, or when\n     *   `updatedAt` is earlier than `createdAt`.\n     */\n    protected constructor(state: EntityState<TIdentifier>) {\n        if (state.id == null) {\n            throw new InvariantViolationException(\n                \"id is required: an entity cannot exist without an identity\",\n            );\n        }\n\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 (this.constructor as typeof 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     * `updatedAt` is monotonic: each call must be at or after the current\n     * `updatedAt` (equal is fine — two mutations can share a millisecond).\n     * Without this, the version counter would advance while the timestamp\n     * walked backwards, corrupting any audit trail or ordering that reads\n     * `updatedAt`. A caller replaying out-of-order events must sort them first.\n     *\n     * @param updatedAt - The modification instant; defaults to now.\n     * @returns The new aggregate version after the increment.\n     * @throws {InvariantViolationException} When `updatedAt` is earlier than\n     *   the current `updatedAt`.\n     */\n    protected markAsModified(updatedAt: Date = new Date()): number {\n        assertValidDate(\"updatedAt\", updatedAt);\n\n        if (updatedAt.getTime() < this._updatedAt.getTime()) {\n            throw new InvariantViolationException(\n                \"updatedAt cannot move backwards: it must be at or after the current updatedAt\",\n            );\n        }\n\n        this._updatedAt = cloneDate(updatedAt);\n        this._aggregateVersion += 1;\n\n        return this._aggregateVersion;\n    }\n\n    /**\n     * Identity-based equality — the semantics that define an entity. Two\n     * entities are equal when they are the same concrete class and their ids\n     * match, regardless of any other field.\n     *\n     * The class check keeps a `CustomerId`-bearing entity from equalling an\n     * unrelated entity that happens to reuse the same raw id. Value-object ids\n     * are compared through their own `equals`, so two independently\n     * reconstituted id instances still match; primitive ids use `===`.\n     */\n    public equals(other: Entity<TIdentifier> | null | undefined): boolean {\n        if (other == null) {\n            return false;\n        }\n        if (other === this) {\n            return true;\n        }\n        if (other.constructor !== this.constructor) {\n            return false;\n        }\n\n        const id: unknown = this._id;\n        if (id instanceof ValueObject) {\n            return id.equals(other._id as typeof id);\n        }\n\n        return this._id === other._id;\n    }\n}\n\nexport { Entity, type EntityState };\n","import { UUID_PATTERN } from \"../shared/uuid.js\";\nimport { ValueObject } from \"./value-object.js\";\n\n/**\n * Base class for UUID-backed identity value objects.\n *\n * A domain typically has many of these — `OrderId`, `CustomerId`, `InvoiceId` —\n * all wrapping the same `string` shape. Two problems follow: the UUID format\n * check gets copy-pasted into every one, and because the wrapped shape is\n * identical, TypeScript's structural typing would happily accept an `OrderId`\n * where a `CustomerId` is expected. `UuidIdentifier` solves both: the format\n * lives here once ({@link isValid}), and the `TBrand` phantom tag makes each\n * subtype nominally distinct so the ids cannot be swapped for one another.\n *\n * It deliberately does not impose a factory. Identifiers vary in how they\n * report an invalid value (their own exception type, their own message), so a\n * concrete id adds a validating `create` that calls {@link isValid} plus a\n * `reconstitute` that trusts an already-persisted value:\n *\n * ```ts\n * class OrderId extends UuidIdentifier<\"OrderId\"> {\n *   private constructor(value: string) { super(value); }\n *   static create(raw: string): OrderId {\n *     if (!UuidIdentifier.isValid(raw)) throw new InvalidOrderIdError(raw);\n *     return new OrderId(raw);\n *   }\n *   static reconstitute(value: string): OrderId { return new OrderId(value); }\n * }\n * ```\n *\n * @typeParam TBrand - A unique string literal that nominally tags the subtype.\n */\nabstract class UuidIdentifier<\n    TBrand extends string = string,\n> extends ValueObject<string, string> {\n    /**\n     * Phantom brand. Never assigned at runtime (`declare`), it exists only so\n     * two identifiers with different brands are not interchangeable at the type\n     * level despite sharing the same `string` value.\n     */\n    declare protected readonly __brand: TBrand;\n\n    protected constructor(value: string) {\n        super(value);\n    }\n\n    public toPrimitive(): string {\n        return this.value;\n    }\n\n    /** The wrapped UUID string — convenient for logging and interpolation. */\n    public toString(): string {\n        return this.value;\n    }\n\n    /**\n     * Whether `candidate` is a canonical UUID (versions 1–8, including the\n     * time-ordered v7; nil and max UUIDs are rejected as sentinels). The single\n     * source of truth for the format — see `shared/uuid.ts`; concrete\n     * identifiers call this from `create`.\n     */\n    public static isValid(candidate: string): boolean {\n        return UUID_PATTERN.test(candidate);\n    }\n}\n\nexport { UuidIdentifier };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAoCA,IAAA,SAAA,MACe,OAAoB;;;;;;;;;;;;;;;;CAuB/B,YAAsB,OAAiC;EACnD,IAAI,MAAM,MAAM,MACZ,MAAM,IAAI,4BACN,4DACJ;EAGJ,gBAAgB,aAAa,MAAM,SAAS;EAC5C,gBAAgB,aAAa,MAAM,SAAS;EAC5C,4BAA4B,MAAM,gBAAgB;EAElD,IAAI,MAAM,UAAU,QAAQ,IAAI,MAAM,UAAU,QAAQ,GACpD,MAAM,IAAI,4BACN,4CACJ;EAGJ,KAAK,MAAM,MAAM;EACjB,KAAK,aAAa,UAAU,MAAM,SAAS;EAC3C,KAAK,aAAa,UAAU,MAAM,SAAS;EAC3C,KAAK,oBAAoB,MAAM;CACnC;;CAGA,IAAW,KAAkB;EACzB,OAAO,KAAK;CAChB;;;;;;;CAQA,IAAW,YAAkB;EACzB,OAAO,UAAU,KAAK,UAAU;CACpC;;;;;;;CAQA,IAAW,YAAkB;EACzB,OAAO,UAAU,KAAK,UAAU;CACpC;;;;;;CAOA,IAAW,mBAA2B;EAClC,OAAO,KAAK;CAChB;;;;;;CAOA,IAAW,kBAAmC;EAC1C,OAAQ,KAAK,YAA8B;CAC/C;;;;;;;;;;;;;;;;;;CAmBA,eAAyB,4BAAkB,IAAI,KAAK,GAAW;EAC3D,gBAAgB,aAAa,SAAS;EAEtC,IAAI,UAAU,QAAQ,IAAI,KAAK,WAAW,QAAQ,GAC9C,MAAM,IAAI,4BACN,+EACJ;EAGJ,KAAK,aAAa,UAAU,SAAS;EACrC,KAAK,qBAAqB;EAE1B,OAAO,KAAK;CAChB;;;;;;;;;;;CAYA,OAAc,OAAwD;EAClE,IAAI,SAAS,MACT,OAAO;EAEX,IAAI,UAAU,MACV,OAAO;EAEX,IAAI,MAAM,gBAAgB,KAAK,aAC3B,OAAO;EAGX,MAAM,KAAc,KAAK;EACzB,IAAI,cAAc,aACd,OAAO,GAAG,OAAO,MAAM,GAAgB;EAG3C,OAAO,KAAK,QAAQ,MAAM;CAC9B;AACJ;qBAtJC,QAAQ,KAAK,CAAA,GAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACJd,IAAe,iBAAf,cAEU,YAA4B;CAQlC,YAAsB,OAAe;EACjC,MAAM,KAAK;CACf;CAEA,cAA6B;EACzB,OAAO,KAAK;CAChB;;CAGA,WAA0B;EACtB,OAAO,KAAK;CAChB;;;;;;;CAQA,OAAc,QAAQ,WAA4B;EAC9C,OAAO,aAAa,KAAK,SAAS;CACtC;AACJ"}

package/dist/uuid.cjs

@@ -0,0 +1,23 @@
+//#region src/core/shared/uuid.ts
+/**
+* Canonical RFC-4122 / RFC-9562 UUID, matched case-insensitively. Accepts
+* versions 1–8 (variant 8/9/a/b) — notably UUIDv7, the time-ordered default for
+* sortable primary keys in modern schemas. The nil (`0000…`) and max (`ffff…`)
+* UUIDs are intentionally rejected: they are sentinels, not real identities, and
+* a domain id should never carry one.
+*
+* The single source of truth for the UUID format — `UuidIdentifier` (domain ids)
+* and `RequestedBy` (command actor) both validate against this pattern, so an
+* identity accepted at the application boundary is always one the domain also
+* considers valid.
+*/
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+//#endregion
+Object.defineProperty(exports, "UUID_PATTERN", {
+	enumerable: true,
+	get: function() {
+		return UUID_PATTERN;
+	}
+});
+
+//# sourceMappingURL=uuid.cjs.map

package/dist/uuid.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid.cjs","names":[],"sources":["../src/core/shared/uuid.ts"],"sourcesContent":["/**\n * Canonical RFC-4122 / RFC-9562 UUID, matched case-insensitively. Accepts\n * versions 1–8 (variant 8/9/a/b) — notably UUIDv7, the time-ordered default for\n * sortable primary keys in modern schemas. The nil (`0000…`) and max (`ffff…`)\n * UUIDs are intentionally rejected: they are sentinels, not real identities, and\n * a domain id should never carry one.\n *\n * The single source of truth for the UUID format — `UuidIdentifier` (domain ids)\n * and `RequestedBy` (command actor) both validate against this pattern, so an\n * identity accepted at the application boundary is always one the domain also\n * considers valid.\n */\nconst UUID_PATTERN =\n    /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;\n\nexport { UUID_PATTERN };\n"],"mappings":";;;;;;;;;;;;;AAYA,MAAM,eACF"}

package/dist/uuid.js

@@ -0,0 +1,18 @@
+//#region src/core/shared/uuid.ts
+/**
+* Canonical RFC-4122 / RFC-9562 UUID, matched case-insensitively. Accepts
+* versions 1–8 (variant 8/9/a/b) — notably UUIDv7, the time-ordered default for
+* sortable primary keys in modern schemas. The nil (`0000…`) and max (`ffff…`)
+* UUIDs are intentionally rejected: they are sentinels, not real identities, and
+* a domain id should never carry one.
+*
+* The single source of truth for the UUID format — `UuidIdentifier` (domain ids)
+* and `RequestedBy` (command actor) both validate against this pattern, so an
+* identity accepted at the application boundary is always one the domain also
+* considers valid.
+*/
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+//#endregion
+export { UUID_PATTERN as t };
+
+//# sourceMappingURL=uuid.js.map

package/dist/uuid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid.js","names":[],"sources":["../src/core/shared/uuid.ts"],"sourcesContent":["/**\n * Canonical RFC-4122 / RFC-9562 UUID, matched case-insensitively. Accepts\n * versions 1–8 (variant 8/9/a/b) — notably UUIDv7, the time-ordered default for\n * sortable primary keys in modern schemas. The nil (`0000…`) and max (`ffff…`)\n * UUIDs are intentionally rejected: they are sentinels, not real identities, and\n * a domain id should never carry one.\n *\n * The single source of truth for the UUID format — `UuidIdentifier` (domain ids)\n * and `RequestedBy` (command actor) both validate against this pattern, so an\n * identity accepted at the application boundary is always one the domain also\n * considers valid.\n */\nconst UUID_PATTERN =\n    /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;\n\nexport { UUID_PATTERN };\n"],"mappings":";;;;;;;;;;;;;AAYA,MAAM,eACF"}

package/dist/validation-code.cjs

@@ -6,6 +6,15 @@ var ValidationCode = class ValidationCode {
 	static of(value) {
 		return new ValidationCode(value);
 	}
+	toString() {
+		return this.value;
+	}
+	equals(other) {
+		return this.value === other.value;
+	}
+	toJSON() {
+		return this.value;
+	}
 	static {
 		this.BLANK = new ValidationCode("blank");
 	}

package/dist/validation-code.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"validation-code.cjs","names":[],"sources":["../src/core/exceptions/validation-code.ts"],"sourcesContent":["// Object-oriented representation of validation codes (similar to Kotlin inline class).\n// Provides common reusable codes while allowing custom codes via `of`.\n\nclass ValidationCode {\n    public readonly value: string;\n\n    private constructor(value: string) {\n        this.value = value;\n    }\n\n    // Factory for custom codes\n    public static of(value: string): ValidationCode {\n        return new ValidationCode(value);\n    }\n\n    // Common, domain-friendly codes\n    public static readonly BLANK = new ValidationCode(\"blank\");\n    public static readonly REQUIRED = new ValidationCode(\"required\");\n    public static readonly INVALID_FORMAT = new ValidationCode(\n        \"invalid_format\",\n    );\n    public static readonly INVALID_CHARACTERS = new ValidationCode(\n        \"invalid_characters\",\n    );\n    public static readonly INVALID_LENGTH = new ValidationCode(\n        \"invalid_length\",\n    );\n    public static readonly TOO_SHORT = new ValidationCode(\"too_short\");\n    public static readonly TOO_LONG = new ValidationCode(\"too_long\");\n    public static readonly OUT_OF_RANGE = new ValidationCode(\"out_of_range\");\n    public static readonly INVALID_CHECKSUM = new ValidationCode(\n        \"invalid_checksum\",\n    );\n    public static readonly INVALID_CHECKING_DIGIT = new ValidationCode(\n        \"invalid_checking_digit\",\n    );\n    public static readonly ALREADY_EXISTS = new ValidationCode(\n        \"already_exists\",\n    );\n    public static readonly NOT_FOUND = new ValidationCode(\"not_found\");\n    public static readonly NOT_ALLOWED = new ValidationCode(\"not_allowed\");\n    public static readonly UNEXPECTED = new ValidationCode(\"unexpected\");\n}\n\nexport { ValidationCode };\n"],"mappings":";AAGA,IAAM,iBAAN,MAAM,eAAe;CAGjB,YAAoB,OAAe;EAC/B,KAAK,QAAQ;CACjB;CAGA,OAAc,GAAG,OAA+B;EAC5C,OAAO,IAAI,eAAe,KAAK;CACnC;;eAG+B,IAAI,eAAe,OAAO;;;kBACvB,IAAI,eAAe,UAAU;;;wBACvB,IAAI,eACxC,gBACJ;;;4BAC4C,IAAI,eAC5C,oBACJ;;;wBACwC,IAAI,eACxC,gBACJ;;;mBACmC,IAAI,eAAe,WAAW;;;kBAC/B,IAAI,eAAe,UAAU;;;sBACzB,IAAI,eAAe,cAAc;;;0BAC7B,IAAI,eAC1C,kBACJ;;;gCACgD,IAAI,eAChD,wBACJ;;;wBACwC,IAAI,eACxC,gBACJ;;;mBACmC,IAAI,eAAe,WAAW;;;qBAC5B,IAAI,eAAe,aAAa;;;oBACjC,IAAI,eAAe,YAAY;;AACvE"}
+{"version":3,"file":"validation-code.cjs","names":[],"sources":["../src/core/exceptions/validation-code.ts"],"sourcesContent":["// Object-oriented representation of validation codes (similar to Kotlin inline class).\n// Provides common reusable codes while allowing custom codes via `of`.\n\nclass ValidationCode {\n    public readonly value: string;\n\n    private constructor(value: string) {\n        this.value = value;\n    }\n\n    // Factory for custom codes\n    public static of(value: string): ValidationCode {\n        return new ValidationCode(value);\n    }\n\n    public toString(): string {\n        return this.value;\n    }\n\n    public equals(other: ValidationCode): boolean {\n        return this.value === other.value;\n    }\n\n    // Serialize to the bare code string, so JSON.stringify of a violation\n    // yields \"blank\" rather than { \"value\": \"blank\" }. Mirrors ValidationField.\n    public toJSON(): string {\n        return this.value;\n    }\n\n    // Common, domain-friendly codes\n    public static readonly BLANK = new ValidationCode(\"blank\");\n    public static readonly REQUIRED = new ValidationCode(\"required\");\n    public static readonly INVALID_FORMAT = new ValidationCode(\n        \"invalid_format\",\n    );\n    public static readonly INVALID_CHARACTERS = new ValidationCode(\n        \"invalid_characters\",\n    );\n    public static readonly INVALID_LENGTH = new ValidationCode(\n        \"invalid_length\",\n    );\n    public static readonly TOO_SHORT = new ValidationCode(\"too_short\");\n    public static readonly TOO_LONG = new ValidationCode(\"too_long\");\n    public static readonly OUT_OF_RANGE = new ValidationCode(\"out_of_range\");\n    public static readonly INVALID_CHECKSUM = new ValidationCode(\n        \"invalid_checksum\",\n    );\n    public static readonly INVALID_CHECKING_DIGIT = new ValidationCode(\n        \"invalid_checking_digit\",\n    );\n    public static readonly ALREADY_EXISTS = new ValidationCode(\n        \"already_exists\",\n    );\n    public static readonly NOT_FOUND = new ValidationCode(\"not_found\");\n    public static readonly NOT_ALLOWED = new ValidationCode(\"not_allowed\");\n    public static readonly UNEXPECTED = new ValidationCode(\"unexpected\");\n}\n\nexport { ValidationCode };\n"],"mappings":";AAGA,IAAM,iBAAN,MAAM,eAAe;CAGjB,YAAoB,OAAe;EAC/B,KAAK,QAAQ;CACjB;CAGA,OAAc,GAAG,OAA+B;EAC5C,OAAO,IAAI,eAAe,KAAK;CACnC;CAEA,WAA0B;EACtB,OAAO,KAAK;CAChB;CAEA,OAAc,OAAgC;EAC1C,OAAO,KAAK,UAAU,MAAM;CAChC;CAIA,SAAwB;EACpB,OAAO,KAAK;CAChB;;eAG+B,IAAI,eAAe,OAAO;;;kBACvB,IAAI,eAAe,UAAU;;;wBACvB,IAAI,eACxC,gBACJ;;;4BAC4C,IAAI,eAC5C,oBACJ;;;wBACwC,IAAI,eACxC,gBACJ;;;mBACmC,IAAI,eAAe,WAAW;;;kBAC/B,IAAI,eAAe,UAAU;;;sBACzB,IAAI,eAAe,cAAc;;;0BAC7B,IAAI,eAC1C,kBACJ;;;gCACgD,IAAI,eAChD,wBACJ;;;wBACwC,IAAI,eACxC,gBACJ;;;mBACmC,IAAI,eAAe,WAAW;;;qBAC5B,IAAI,eAAe,aAAa;;;oBACjC,IAAI,eAAe,YAAY;;AACvE"}

package/dist/validation-code.d.cts

@@ -3,6 +3,9 @@ declare class ValidationCode {
   readonly value: string;
   private constructor();
   static of(value: string): ValidationCode;
+  toString(): string;
+  equals(other: ValidationCode): boolean;
+  toJSON(): string;
   static readonly BLANK: ValidationCode;
   static readonly REQUIRED: ValidationCode;
   static readonly INVALID_FORMAT: ValidationCode;

package/dist/validation-code.d.ts

@@ -3,6 +3,9 @@ declare class ValidationCode {
   readonly value: string;
   private constructor();
   static of(value: string): ValidationCode;
+  toString(): string;
+  equals(other: ValidationCode): boolean;
+  toJSON(): string;
   static readonly BLANK: ValidationCode;
   static readonly REQUIRED: ValidationCode;
   static readonly INVALID_FORMAT: ValidationCode;

package/dist/validation-code.js

@@ -6,6 +6,15 @@ var ValidationCode = class ValidationCode {
 	static of(value) {
 		return new ValidationCode(value);
 	}
+	toString() {
+		return this.value;
+	}
+	equals(other) {
+		return this.value === other.value;
+	}
+	toJSON() {
+		return this.value;
+	}
 	static {
 		this.BLANK = new ValidationCode("blank");
 	}

package/dist/validation-code.js.map

@@ -1 +1 @@
-{"version":3,"file":"validation-code.js","names":[],"sources":["../src/core/exceptions/validation-code.ts"],"sourcesContent":["// Object-oriented representation of validation codes (similar to Kotlin inline class).\n// Provides common reusable codes while allowing custom codes via `of`.\n\nclass ValidationCode {\n    public readonly value: string;\n\n    private constructor(value: string) {\n        this.value = value;\n    }\n\n    // Factory for custom codes\n    public static of(value: string): ValidationCode {\n        return new ValidationCode(value);\n    }\n\n    // Common, domain-friendly codes\n    public static readonly BLANK = new ValidationCode(\"blank\");\n    public static readonly REQUIRED = new ValidationCode(\"required\");\n    public static readonly INVALID_FORMAT = new ValidationCode(\n        \"invalid_format\",\n    );\n    public static readonly INVALID_CHARACTERS = new ValidationCode(\n        \"invalid_characters\",\n    );\n    public static readonly INVALID_LENGTH = new ValidationCode(\n        \"invalid_length\",\n    );\n    public static readonly TOO_SHORT = new ValidationCode(\"too_short\");\n    public static readonly TOO_LONG = new ValidationCode(\"too_long\");\n    public static readonly OUT_OF_RANGE = new ValidationCode(\"out_of_range\");\n    public static readonly INVALID_CHECKSUM = new ValidationCode(\n        \"invalid_checksum\",\n    );\n    public static readonly INVALID_CHECKING_DIGIT = new ValidationCode(\n        \"invalid_checking_digit\",\n    );\n    public static readonly ALREADY_EXISTS = new ValidationCode(\n        \"already_exists\",\n    );\n    public static readonly NOT_FOUND = new ValidationCode(\"not_found\");\n    public static readonly NOT_ALLOWED = new ValidationCode(\"not_allowed\");\n    public static readonly UNEXPECTED = new ValidationCode(\"unexpected\");\n}\n\nexport { ValidationCode };\n"],"mappings":";AAGA,IAAM,iBAAN,MAAM,eAAe;CAGjB,YAAoB,OAAe;EAC/B,KAAK,QAAQ;CACjB;CAGA,OAAc,GAAG,OAA+B;EAC5C,OAAO,IAAI,eAAe,KAAK;CACnC;;eAG+B,IAAI,eAAe,OAAO;;;kBACvB,IAAI,eAAe,UAAU;;;wBACvB,IAAI,eACxC,gBACJ;;;4BAC4C,IAAI,eAC5C,oBACJ;;;wBACwC,IAAI,eACxC,gBACJ;;;mBACmC,IAAI,eAAe,WAAW;;;kBAC/B,IAAI,eAAe,UAAU;;;sBACzB,IAAI,eAAe,cAAc;;;0BAC7B,IAAI,eAC1C,kBACJ;;;gCACgD,IAAI,eAChD,wBACJ;;;wBACwC,IAAI,eACxC,gBACJ;;;mBACmC,IAAI,eAAe,WAAW;;;qBAC5B,IAAI,eAAe,aAAa;;;oBACjC,IAAI,eAAe,YAAY;;AACvE"}
+{"version":3,"file":"validation-code.js","names":[],"sources":["../src/core/exceptions/validation-code.ts"],"sourcesContent":["// Object-oriented representation of validation codes (similar to Kotlin inline class).\n// Provides common reusable codes while allowing custom codes via `of`.\n\nclass ValidationCode {\n    public readonly value: string;\n\n    private constructor(value: string) {\n        this.value = value;\n    }\n\n    // Factory for custom codes\n    public static of(value: string): ValidationCode {\n        return new ValidationCode(value);\n    }\n\n    public toString(): string {\n        return this.value;\n    }\n\n    public equals(other: ValidationCode): boolean {\n        return this.value === other.value;\n    }\n\n    // Serialize to the bare code string, so JSON.stringify of a violation\n    // yields \"blank\" rather than { \"value\": \"blank\" }. Mirrors ValidationField.\n    public toJSON(): string {\n        return this.value;\n    }\n\n    // Common, domain-friendly codes\n    public static readonly BLANK = new ValidationCode(\"blank\");\n    public static readonly REQUIRED = new ValidationCode(\"required\");\n    public static readonly INVALID_FORMAT = new ValidationCode(\n        \"invalid_format\",\n    );\n    public static readonly INVALID_CHARACTERS = new ValidationCode(\n        \"invalid_characters\",\n    );\n    public static readonly INVALID_LENGTH = new ValidationCode(\n        \"invalid_length\",\n    );\n    public static readonly TOO_SHORT = new ValidationCode(\"too_short\");\n    public static readonly TOO_LONG = new ValidationCode(\"too_long\");\n    public static readonly OUT_OF_RANGE = new ValidationCode(\"out_of_range\");\n    public static readonly INVALID_CHECKSUM = new ValidationCode(\n        \"invalid_checksum\",\n    );\n    public static readonly INVALID_CHECKING_DIGIT = new ValidationCode(\n        \"invalid_checking_digit\",\n    );\n    public static readonly ALREADY_EXISTS = new ValidationCode(\n        \"already_exists\",\n    );\n    public static readonly NOT_FOUND = new ValidationCode(\"not_found\");\n    public static readonly NOT_ALLOWED = new ValidationCode(\"not_allowed\");\n    public static readonly UNEXPECTED = new ValidationCode(\"unexpected\");\n}\n\nexport { ValidationCode };\n"],"mappings":";AAGA,IAAM,iBAAN,MAAM,eAAe;CAGjB,YAAoB,OAAe;EAC/B,KAAK,QAAQ;CACjB;CAGA,OAAc,GAAG,OAA+B;EAC5C,OAAO,IAAI,eAAe,KAAK;CACnC;CAEA,WAA0B;EACtB,OAAO,KAAK;CAChB;CAEA,OAAc,OAAgC;EAC1C,OAAO,KAAK,UAAU,MAAM;CAChC;CAIA,SAAwB;EACpB,OAAO,KAAK;CAChB;;eAG+B,IAAI,eAAe,OAAO;;;kBACvB,IAAI,eAAe,UAAU;;;wBACvB,IAAI,eACxC,gBACJ;;;4BAC4C,IAAI,eAC5C,oBACJ;;;wBACwC,IAAI,eACxC,gBACJ;;;mBACmC,IAAI,eAAe,WAAW;;;kBAC/B,IAAI,eAAe,UAAU;;;sBACzB,IAAI,eAAe,cAAc;;;0BAC7B,IAAI,eAC1C,kBACJ;;;gCACgD,IAAI,eAChD,wBACJ;;;wBACwC,IAAI,eACxC,gBACJ;;;mBACmC,IAAI,eAAe,WAAW;;;qBAC5B,IAAI,eAAe,aAAa;;;oBACjC,IAAI,eAAe,YAAY;;AACvE"}

package/dist/validation-error.cjs

@@ -1,4 +1,6 @@
 const require_app_error = require("./app-error.cjs");
+const require_authorization_error = require("./authorization-error.cjs");
+const require_hashing = require("./hashing.cjs");
 //#region src/core/errors/authentication-error.ts
 var AuthenticationError = class AuthenticationError extends require_app_error.AppError {
 	constructor(params) {
@@ -24,8 +26,8 @@ var AuthenticationError = class AuthenticationError extends require_app_error.Ap
 			message: "Missing credentials",
 			code: require_app_error.ErrorCodes.authentication.missingToken,
 			reason: "missing_token",
-			metadata: compactMetadata$1(options),
-			...extractAppErrorOptions(options)
+			metadata: require_authorization_error.compactMetadata(options),
+			...require_authorization_error.pickAppErrorOptions(options)
 		});
 	}
 	static invalidToken(options) {
@@ -33,14 +35,14 @@ var AuthenticationError = class AuthenticationError extends require_app_error.Ap
 			message: "Invalid credentials",
 			code: require_app_error.ErrorCodes.authentication.invalidToken,
 			reason: "invalid_token",
-			metadata: compactMetadata$1({
+			metadata: require_authorization_error.compactMetadata({
 				authScheme: options?.authScheme,
 				tokenLocation: options?.tokenLocation,
 				details: options?.details,
 				correlationId: options?.correlationId,
 				requestId: options?.requestId
 			}),
-			...extractAppErrorOptions(options)
+			...require_authorization_error.pickAppErrorOptions(options)
 		});
 	}
 	static expiredToken(options) {
@@ -48,8 +50,8 @@ var AuthenticationError = class AuthenticationError extends require_app_error.Ap
 			message: "Expired credentials",
 			code: require_app_error.ErrorCodes.authentication.expiredToken,
 			reason: "expired_token",
-			metadata: compactMetadata$1(options),
-			...extractAppErrorOptions(options)
+			metadata: require_authorization_error.compactMetadata(options),
+			...require_authorization_error.pickAppErrorOptions(options)
 		});
 	}
 	static invalidCredentials(options) {
@@ -57,27 +59,11 @@ var AuthenticationError = class AuthenticationError extends require_app_error.Ap
 			message: "Invalid username or password",
 			code: require_app_error.ErrorCodes.authentication.invalidCredentials,
 			reason: "invalid_credentials",
-			metadata: compactMetadata$1(options),
-			...extractAppErrorOptions(options)
+			metadata: require_authorization_error.compactMetadata(options),
+			...require_authorization_error.pickAppErrorOptions(options)
 		});
 	}
 };
-function extractAppErrorOptions(options) {
-	return {
-		cause: options?.cause,
-		type: options?.type,
-		severity: options?.severity,
-		correlationId: options?.correlationId,
-		requestId: options?.requestId,
-		commandId: options?.commandId,
-		createdAtIso: options?.createdAtIso,
-		publicMessage: options?.publicMessage
-	};
-}
-function compactMetadata$1(input) {
-	if (!input) return void 0;
-	return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0));
-}
 //#endregion
 //#region src/core/errors/conflict-error.ts
 /**
@@ -408,9 +394,10 @@ var IdempotencyReplayNotSupportedError = class IdempotencyReplayNotSupportedErro
 	}
 };
 function resolveKeyIdentity(key, keyHash, keyPreview) {
+	const preview = keyPreview ?? (key ? key.length <= 8 ? key : key.slice(0, 8) : void 0);
 	return {
-		keyHash,
-		keyPreview: keyPreview ?? (key ? key.length <= 8 ? key : key.slice(0, 8) : void 0)
+		keyHash: keyHash ?? (key ? require_hashing.sha256Hex(key) : void 0),
+		keyPreview: preview
 	};
 }
 //#endregion
@@ -450,7 +437,7 @@ var IntegrationError = class IntegrationError extends require_app_error.AppError
 				reason: "timeout",
 				...options
 			}),
-			...pickAppErrorFields(options)
+			...require_authorization_error.pickAppErrorOptions(options)
 		});
 	}
 	/**
@@ -466,7 +453,7 @@ var IntegrationError = class IntegrationError extends require_app_error.AppError
 				reason: "unreachable",
 				...options
 			}),
-			...pickAppErrorFields(options)
+			...require_authorization_error.pickAppErrorOptions(options)
 		});
 	}
 	/**
@@ -483,12 +470,12 @@ var IntegrationError = class IntegrationError extends require_app_error.AppError
 				reason: "bad_response",
 				...options
 			}),
-			...pickAppErrorFields(options)
+			...require_authorization_error.pickAppErrorOptions(options)
 		});
 	}
 };
 function buildMetadata(input) {
-	return compactMetadata({
+	return require_authorization_error.compactMetadata({
 		reason: input.reason,
 		provider: input.provider,
 		operation: input.operation,
@@ -503,21 +490,6 @@ function buildMetadata(input) {
 		responseCode: input.responseCode
 	});
 }
-function pickAppErrorFields(options) {
-	return {
-		cause: options.cause,
-		type: options.type,
-		severity: options.severity,
-		correlationId: options.correlationId,
-		requestId: options.requestId,
-		commandId: options.commandId,
-		createdAtIso: options.createdAtIso,
-		publicMessage: options.publicMessage
-	};
-}
-function compactMetadata(input) {
-	return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0));
-}
 //#endregion
 //#region src/core/errors/legacy-incompatible-error.ts
 var LegacyIncompatibleError = class extends require_app_error.AppError {
@@ -530,6 +502,7 @@ var LegacyIncompatibleError = class extends require_app_error.AppError {
 			...options,
 			metadata: mergedMetadata
 		});
+		Object.freeze(this);
 	}
 };
 //#endregion
@@ -644,17 +617,10 @@ var ExpiredError = class ExpiredError extends TemporalError {
 			code: require_app_error.ErrorCodes.temporal.expired,
 			kind: "expired",
 			metadata: {
-				...input,
+				...require_authorization_error.stripAppErrorOptions(input),
 				hint: input.hint ?? "The window has expired. Request a new link or try again within the valid period."
 			},
-			cause: input.cause,
-			type: input.type,
-			severity: input.severity,
-			correlationId: input.correlationId,
-			requestId: input.requestId,
-			commandId: input.commandId,
-			createdAtIso: input.createdAtIso,
-			publicMessage: input.publicMessage
+			...require_authorization_error.pickAppErrorOptions(input)
 		});
 	}
 };
@@ -668,31 +634,39 @@ var NotYetValidError = class NotYetValidError extends TemporalError {
 			code: require_app_error.ErrorCodes.temporal.notYetValid,
 			kind: "not_yet_valid",
 			metadata: {
-				...input,
+				...require_authorization_error.stripAppErrorOptions(input),
 				hint: input.hint ?? "Not yet within the valid period. Try again later."
 			},
-			cause: input.cause,
-			type: input.type,
-			severity: input.severity,
-			correlationId: input.correlationId,
-			requestId: input.requestId,
-			commandId: input.commandId,
-			createdAtIso: input.createdAtIso,
-			publicMessage: input.publicMessage
+			...require_authorization_error.pickAppErrorOptions(input)
 		});
 	}
 };
+/**
+* Evaluates whether `evaluatedAtIso` falls inside the [`validFromIso`,
+* `validUntilIso`] window.
+*
+* Fails **closed**: a boundary that is present but unparseable is treated as if
+* the window were closed on that side (a bad `validUntilIso` → expired, a bad
+* `validFromIso` → not-yet-valid), never silently ignored — these checks guard
+* access (invites, links, tokens), so a typo in an expiry must not disable
+* expiry. A `null`/absent boundary means "no bound on that side", which is
+* distinct from a malformed one. Returns `null` only when `evaluatedAtIso`
+* itself is unparseable (nothing can be decided).
+*
+* For an inverted window (`validFrom` > `validUntil`) `expired` wins, since the
+* upper-bound check short-circuits.
+*/
 function evaluateTemporalWindow(input) {
 	const evaluatedMs = Date.parse(input.evaluatedAtIso);
 	if (Number.isNaN(evaluatedMs)) return null;
 	let notYetValid = false;
 	if (input.validFromIso) {
 		const fromMs = Date.parse(input.validFromIso);
-		if (!Number.isNaN(fromMs) && evaluatedMs < fromMs) notYetValid = true;
+		if (Number.isNaN(fromMs) || evaluatedMs < fromMs) notYetValid = true;
 	}
 	if (input.validUntilIso) {
 		const untilMs = Date.parse(input.validUntilIso);
-		if (!Number.isNaN(untilMs) && evaluatedMs > untilMs) return {
+		if (Number.isNaN(untilMs) || evaluatedMs > untilMs) return {
 			expired: true,
 			notYetValid: false
 		};
@@ -729,13 +703,14 @@ var ValidationError = class extends require_app_error.AppError {
 			validationCode: code.value
 		};
 		const mergedMetadata = options?.metadata ? {
-			...baseMetadata,
-			...options.metadata
+			...options.metadata,
+			...baseMetadata
 		} : baseMetadata;
 		super(message, require_app_error.ErrorCodes.validation, {
 			...options,
 			metadata: mergedMetadata
 		});
+		Object.freeze(this);
 	}
 };
 //#endregion