@cullet/erp-core 1.0.11 → 1.2.0

package/dist/value-object.js

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

package/dist/value-object.js.map

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

package/dist/version.d.ts

@@ -0,0 +1,10 @@
+//#region src/core/versioning/version.d.ts
+type ContractVersion = `${number}.${number}`;
+type VersionedTarget = {
+  readonly prototype: object;
+};
+declare const CONTRACT_VERSION_PROPERTY: "CONTRACT_VERSION";
+declare function version<const TVersion extends ContractVersion>(contractVersion: TVersion): (target: VersionedTarget) => void;
+//#endregion
+export { version as i, ContractVersion as n, VersionedTarget as r, CONTRACT_VERSION_PROPERTY as t };
+//# sourceMappingURL=version.d.ts.map

package/dist/versioning/index.d.ts

@@ -0,0 +1,3 @@
+import { i as version, n as ContractVersion, r as VersionedTarget, t as CONTRACT_VERSION_PROPERTY } from "../version.js";
+import { a as buildDomainEventContractVersions, i as DomainEventEnvelope, n as DomainEventContractSelection, o as createDomainEventEnvelope, r as DomainEventContractVersions, t as CreateDomainEventEnvelopeInput } from "../domain-event-contracts.js";
+export { CONTRACT_VERSION_PROPERTY, ContractVersion, CreateDomainEventEnvelopeInput, DomainEventContractSelection, DomainEventContractVersions, DomainEventEnvelope, VersionedTarget, buildDomainEventContractVersions, createDomainEventEnvelope, version };

package/dist/versioning/index.js

@@ -0,0 +1,3 @@
+import { i as version, r as CONTRACT_VERSION_PROPERTY } from "../immutable.js";
+import { n as createDomainEventEnvelope, t as buildDomainEventContractVersions } from "../domain-event-contracts.js";
+export { CONTRACT_VERSION_PROPERTY, buildDomainEventContractVersions, createDomainEventEnvelope, version };

package/meta.json

@@ -1,7 +1,7 @@
 {
     "schemaVersion": "2",
     "name": "erp-core",
-    "version": "1.0.11",
+    "version": "1.2.0",
     "description": "Núcleo arquitetural para ERP em TypeScript — entidades, value objects, erros tipados e policies declaráveis sobre clean architecture.",
     "compatibility": {
         "engines": {
@@ -12,7 +12,9 @@
             "peerDependencies": [
                 {
                     "name": "zod",
-                    "range": ">=3.22.0 <5"
+                    "range": ">=3.22.0 <5",
+                    "optional": true,
+                    "notes": "Only required by the `./policies` subpath (gate/compute engines). The domain/result/errors/exceptions/rulesets/versioning/plugins subpaths are zod-free."
                 }
             ]
         },
@@ -51,6 +53,17 @@
     "exports": [
         "Entity",
         "ValueObject",
+        "UuidIdentifier",
+        "PluginManager",
+        "Result",
+        "Outcome",
+        "RulesetRegistry",
+        "DomainException",
+        "InvariantViolationException",
+        "ValidationException",
+        "ValidationField",
+        "version",
+        "createDomainEventEnvelope",
         "AppError",
         "ValidationError",
         "NotFoundError",
@@ -75,7 +88,9 @@
         "1.0.8 - Align kit metadata with what the package actually ships and fix doc/packaging gaps. No runtime or public API changes.",
         "1.0.9 - Harden erp-core invariants and error serialization",
         "1.0.10 - Stop the `meta.json` `changelog` from drifting and clarify the `ValueObject` freeze contract.",
-        "1.0.11 - Document the public API surface with TSDoc."
+        "1.0.11 - Document the public API surface with TSDoc.",
+        "1.1.0 - **New: `ResultRepository`, `UseCaseObservability`, and `./application` subpath**",
+        "1.2.0 - Add zod-free subpaths for the stable core primitives and a value-object equality plugin system."
     ],
     "deprecated": false
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cullet/erp-core",
-    "version": "1.0.11",
+    "version": "1.2.0",
     "description": "Núcleo arquitetural para ERP em TypeScript — entidades, value objects, erros tipados e policies declaráveis sobre clean architecture.",
     "type": "module",
     "repository": {
@@ -15,10 +15,30 @@
             "types": "./dist/index.d.ts",
             "import": "./dist/index.js"
         },
+        "./application": {
+            "types": "./dist/application/index.d.ts",
+            "import": "./dist/application/index.js"
+        },
+        "./domain": {
+            "types": "./dist/domain/index.d.ts",
+            "import": "./dist/domain/index.js"
+        },
         "./errors": {
             "types": "./dist/errors/index.d.ts",
             "import": "./dist/errors/index.js"
         },
+        "./exceptions": {
+            "types": "./dist/exceptions/index.d.ts",
+            "import": "./dist/exceptions/index.js"
+        },
+        "./exceptions/validation-field": {
+            "types": "./dist/exceptions/validation-field.d.ts",
+            "import": "./dist/exceptions/validation-field.js"
+        },
+        "./plugins": {
+            "types": "./dist/plugins/index.d.ts",
+            "import": "./dist/plugins/index.js"
+        },
         "./policies": {
             "types": "./dist/policies/index.d.ts",
             "import": "./dist/policies/index.js"
@@ -31,9 +51,17 @@
             "types": "./dist/policies/engines/v1/gate/index.d.ts",
             "import": "./dist/policies/engines/v1/gate/index.js"
         },
-        "./exceptions/validation-field": {
-            "types": "./dist/exceptions/validation-field.d.ts",
-            "import": "./dist/exceptions/validation-field.js"
+        "./result": {
+            "types": "./dist/result/index.d.ts",
+            "import": "./dist/result/index.js"
+        },
+        "./rulesets": {
+            "types": "./dist/rulesets/index.d.ts",
+            "import": "./dist/rulesets/index.js"
+        },
+        "./versioning": {
+            "types": "./dist/versioning/index.d.ts",
+            "import": "./dist/versioning/index.js"
         },
         "./package.json": "./package.json"
     },
@@ -58,6 +86,11 @@
     "peerDependencies": {
         "zod": ">=3.22.0 <5"
     },
+    "peerDependenciesMeta": {
+        "zod": {
+            "optional": true
+        }
+    },
     "publishConfig": {
         "access": "public"
     },

package/src/application/index.ts

@@ -0,0 +1 @@
+export * from "../core/application/index.js";

package/src/core/application/commands/index.ts

@@ -1,2 +1,3 @@
 export type { CommandInput } from "./command.js";
 export { Command } from "./command.js";
+export { RequestedBy, type RequestedByKind } from "./requested-by.js";

package/src/core/application/index.ts

@@ -1,15 +1,20 @@
 export type { CommandInput } from "./commands/index.js";
-export { Command } from "./commands/index.js";
+export {
+    Command,
+    RequestedBy,
+    type RequestedByKind,
+} from "./commands/index.js";
 export type {
     LogPayload,
     LoggerPort,
     MetricLabels,
     MetricsPort,
-    PolicyEvaluationError,
     PolicyEvaluationInput,
     PolicyEvaluationOutput,
     PolicyPort,
+    PolicyPortError,
     Repository,
+    ResultRepository,
     TraceAttributeValue,
     TraceSpan,
     TracerPort,
@@ -28,4 +33,8 @@ export {
     TemporalUseCase,
     type TemporalUseCaseInput,
 } from "./temporal/index.js";
-export { type MaybePromise, UseCase } from "./use-case.js";
+export {
+    type MaybePromise,
+    UseCase,
+    type UseCaseObservability,
+} from "./use-case.js";

package/src/core/application/ports/index.ts

@@ -1,12 +1,12 @@
 export type { LogPayload, LoggerPort } from "./logger.port.js";
 export type { MetricLabels, MetricsPort } from "./metrics.port.js";
 export type {
-    PolicyEvaluationError,
     PolicyEvaluationInput,
     PolicyEvaluationOutput,
     PolicyPort,
+    PolicyPortError,
 } from "./policy-port.js";
-export type { Repository } from "./repository.port.js";
+export type { Repository, ResultRepository } from "./repository.port.js";
 export type {
     TemporalHistory,
     TemporalRepository,

package/src/core/application/ports/policy-port.ts

@@ -7,17 +7,27 @@ import type { Result } from "../../result/result.js";
 
 type PolicyEvaluationInput = EvaluateInput;
 type PolicyEvaluationOutput = PolicyEvaluationResult;
-type PolicyEvaluationError = AppError;
+
+/**
+ * Failure surfaced by {@link PolicyPort.evaluate}.
+ *
+ * This is the *post-mapping* boundary: the structured `PolicyEvaluationError`
+ * union produced inside the policies module is expected to have already been
+ * translated into an {@link AppError} (e.g. via `mapPolicyEvaluationError`)
+ * before it reaches a use case. Named distinctly from the policies-layer
+ * `PolicyEvaluationError` to avoid a collision on the public surface.
+ */
+type PolicyPortError = AppError;
 
 interface PolicyPort {
     evaluate(
         input: PolicyEvaluationInput,
-    ): Promise<Result<PolicyEvaluationOutput, PolicyEvaluationError>>;
+    ): Promise<Result<PolicyEvaluationOutput, PolicyPortError>>;
 }
 
 export type {
-    PolicyEvaluationError,
     PolicyEvaluationInput,
     PolicyEvaluationOutput,
     PolicyPort,
+    PolicyPortError,
 };

package/src/core/application/ports/repository.port.ts

@@ -1,7 +1,43 @@
+import type { AppError } from "../../errors/index.js";
+import type { Result } from "../../result/result.js";
+
+/**
+ * Persistence port for an aggregate in the imperative style: absence is
+ * modelled as `null`, and failures (missing row on delete, optimistic
+ * concurrency conflicts, infrastructure errors) surface as thrown exceptions.
+ *
+ * Prefer {@link ResultRepository} when you want those persistence outcomes to
+ * be explicit, recoverable values rather than exceptions.
+ */
 interface Repository<TEntity, TId> {
     findById(id: TId): Promise<TEntity | null>;
     save(entity: TEntity): Promise<void>;
     delete(id: TId): Promise<void>;
 }
 
-export type { Repository };
+/**
+ * `Result`-returning counterpart of {@link Repository}, aligned with the
+ * "errors as values" philosophy used by `Command` / `UseCase`.
+ *
+ * Where {@link Repository} returns `Promise<void>` from `save`/`delete` and
+ * relies on thrown exceptions, this variant lets a repository *signal*
+ * recoverable persistence outcomes without breaking control flow — for
+ * example a `NotFoundError` when updating/deleting a missing aggregate, or a
+ * `ConflictError` on an optimistic-concurrency version mismatch. A successful
+ * write resolves to `Result.ok(undefined)`.
+ *
+ * `findById` keeps `null` as the "not present" answer to a lookup (not an
+ * error) while still wrapping the call in a `Result` so genuine failures
+ * (e.g. a connectivity error) stay in band.
+ *
+ * `TError` defaults to {@link AppError} to match the rest of the application
+ * boundary (see `PolicyPortError`); narrow it per repository when the failure
+ * set is known, e.g. `ResultRepository<Order, OrderId, NotFoundError | ConflictError>`.
+ */
+interface ResultRepository<TEntity, TId, TError = AppError> {
+    findById(id: TId): Promise<Result<TEntity | null, TError>>;
+    save(entity: TEntity): Promise<Result<void, TError>>;
+    delete(id: TId): Promise<Result<void, TError>>;
+}
+
+export type { Repository, ResultRepository };

package/src/core/application/temporal/temporal-use-case.ts

@@ -11,7 +11,19 @@ interface TemporalUseCaseInput {
     readonly temporalContext?: TemporalContext;
 }
 
-type TemporalizedContextSeed<TSeed extends ContextSeed> = TSeed;
+/**
+ * A {@link ContextSeed} after temporal enrichment by
+ * {@link TemporalUseCase.buildPolicySeed}: structurally identical to `TSeed`,
+ * except `fields.now` is now guaranteed present as a `Date` (injected from the
+ * resolved {@link TemporalContext}). Downstream policies can therefore read
+ * `seed.fields.now` without a presence/type guard.
+ */
+type TemporalizedContextSeed<TSeed extends ContextSeed> = Omit<
+    TSeed,
+    "fields"
+> & {
+    readonly fields: TSeed["fields"] & { readonly now: Date };
+};
 
 abstract class TemporalUseCase<
     Input extends object,
@@ -33,7 +45,7 @@ abstract class TemporalUseCase<
                 ...seed.fields,
                 now: new Date(temporalContext.requestedAt.getTime()),
             },
-        }) as TSeed;
+        }) as TemporalizedContextSeed<TSeed>;
     }
 }