@cullet/erp-core 1.1.0 → 1.2.0

package/dist/index.js

@@ -1,194 +1,37 @@
-import { a as ErrorCodes, i as assertJsonSafeMetadata, n as UnexpectedError, o as serializationErrorCode, r as AppError } from "./validation-code.js";
+import { a as serializationErrorCode, i as ErrorCodes, n as AppError, r as assertJsonSafeMetadata, t as UnexpectedError } from "./unexpected-error.js";
 import { C as translateUniqueViolationToDuplicate, S as UniqueConstraintViolationError, T as AuthenticationError, _ 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 AuthorizationError, x as DuplicateError, y as AlreadyExistsError } from "./validation-error.js";
 import { n as BusinessRuleViolationError, t as NotFoundError } from "./not-found-error.js";
 import { n as sha256Hex, r as stableStringify, t as payloadHash } from "./hashing.js";
+import { t as ValidationCode } from "./validation-code.js";
 import { t as ValidationField } from "./validation-field.js";
-import { a as Query, c as RequestedBy, d as version$1, i as makeImmutable, l as UseCase, n as assertTemporalContext, o as mapPolicyEvaluationError, r as createTemporalContext, s as Command, t as TemporalUseCase, u as __decorate } from "./temporal-use-case.js";
-import { i as InvariantViolationException, n as cloneDate, t as assertValidDate } from "./temporal-guards.js";
-import { c as Ok, d as CoreConfig, l as Result, o as PolicyContextPath, s as Err, u as coreConfig } from "./gate-v1-payload.schema.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";
+import { i as version, r as CONTRACT_VERSION_PROPERTY } from "./immutable.js";
+import { t as UseCase } from "./use-case.js";
+import { a as mapPolicyEvaluationError, i as Query, n as assertTemporalContext, o as Command, r as createTemporalContext, s as RequestedBy, t as TemporalUseCase } from "./temporal-use-case.js";
+import { n as Entity, t as ValueObject } from "./value-object.js";
+import { t as PluginManager } from "./plugin.js";
+import { t as UuidIdentifier } from "./uuid-identifier.js";
+import { t as RulesetRegistry } from "./ruleset-registry.js";
+import { n as createDomainEventEnvelope, t as buildDomainEventContractVersions } from "./domain-event-contracts.js";
+import { c as CoreConfig, o as PolicyContextPath, s as coreConfig } from "./gate-v1-payload.schema.js";
+import { n as Ok, r as Result, t as Err } from "./result.js";
 import { t as Outcome } from "./outcome.js";
 import { _ as asPolicyDecisionId, a as ContextSeedValidator, b as asTenantId, c as ContextResolverRegistry, d as PolicyDefinition, f as InMemoryPolicyDefinitionRepository, g as PolicyCatalog, h as PolicyCatalogFactory, i as PolicyAsOfResolver, l as registerNamespacedContextResolversIn, m as PolicyKey, n as PolicyEvaluationErrors, o as contextResolverRegistry, p as PolicyScopeMatcher, r as PolicyResolver, s as registerNamespacedContextResolvers, t as PolicyService, u as PolicyContextBuilder, v as asPolicyDefinitionId, x as PolicyHashing, y as asSchoolId } from "./policy-service.js";
 import { a as ComputeEvaluatorRegistry, c as ComputePayloadParsers, i as ComputeRegistry, o as ComputeEngineRegistry, r as GatePayloadParsers, s as ComputePayloadParserRegistry, t as GateEngineRegistry } from "./gate-engine-registry.js";
 //#region src/version.ts
-const version = "1.1.0";
-//#endregion
-//#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("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;
-	}
-	/**
-	* 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();
-	}
-};
-ValueObject = _ValueObject = __decorate([version$1("1.0")], ValueObject);
+const version$1 = "1.2.0";
 //#endregion
 //#region src/index.ts
 const ERP_CORE_NAME = "erp-core";
-const ERP_CORE_VERSION = version;
+const ERP_CORE_VERSION = version$1;
 const erpCoreRelease = {
 	name: ERP_CORE_NAME,
 	version: ERP_CORE_VERSION
 };
 //#endregion
-export { AlreadyExistsError, AppError, AuthenticationError, AuthorizationError, BusinessRuleViolationError, Command, ComputeEngineRegistry, ComputeEvaluatorRegistry, ComputePayloadParserRegistry, ComputePayloadParsers, ComputeRegistry, ConflictError, ContextResolverRegistry, ContextSeedValidator, CoreConfig, SerializationInError as DeserializationError, SerializationInError, DuplicateError, ERP_CORE_NAME, ERP_CORE_VERSION, Entity, Err, ErrorCodes, ExpiredError, GateEngineRegistry, GatePayloadParsers, IdempotencyError, IdempotencyInProgressError, IdempotencyKeyMissingError, IdempotencyPayloadMismatchError, IdempotencyReplayNotSupportedError, InMemoryPolicyDefinitionRepository, IntegrationError, LegacyIncompatibleError, NotFoundError, NotYetValidError, Ok, Outcome, PolicyAsOfResolver, PolicyCatalog, PolicyCatalogFactory, PolicyContextBuilder, PolicyContextPath, PolicyDefinition, PolicyEvaluationErrors, PolicyHashing, PolicyKey, PolicyResolver, PolicyScopeMatcher, PolicyService, Query, RequestedBy, Result, SerializationCodes, SerializationError, SerializationMessages, SerializationOutError, TemporalError, TemporalUseCase, UnexpectedError, UniqueConstraintViolationError, UseCase, ValidationError, ValidationField, ValueObject, asPolicyDecisionId, asPolicyDefinitionId, asSchoolId, asTenantId, assertJsonSafeMetadata, assertTemporalContext, contextResolverRegistry, coreConfig, createTemporalContext, erpCoreRelease, evaluateTemporalWindow, mapPolicyEvaluationError, payloadHash, registerNamespacedContextResolvers, registerNamespacedContextResolversIn, safePreview, serializationErrorCode, sha256Hex, stableStringify, translateUniqueViolationToDuplicate };
+export { AlreadyExistsError, AppError, AuthenticationError, AuthorizationError, BusinessRuleViolationError, BusinessRuleViolationException, CONTRACT_VERSION_PROPERTY, Command, ComputeEngineRegistry, ComputeEvaluatorRegistry, ComputePayloadParserRegistry, ComputePayloadParsers, ComputeRegistry, ConflictError, ContextResolverRegistry, ContextSeedValidator, CoreConfig, SerializationInError as DeserializationError, SerializationInError, DomainException, DuplicateError, ERP_CORE_NAME, ERP_CORE_VERSION, Entity, EntityNotFoundException, Err, ErrorCodes, ExpiredError, GateEngineRegistry, GatePayloadParsers, IdempotencyError, IdempotencyInProgressError, IdempotencyKeyMissingError, IdempotencyPayloadMismatchError, IdempotencyReplayNotSupportedError, InMemoryPolicyDefinitionRepository, IntegrationError, InvalidStateTransitionException, InvalidValueException, InvariantViolationException, LegacyIncompatibleError, MultipleValidationException, NotFoundError, NotYetValidError, Ok, Outcome, PluginManager, PolicyAsOfResolver, PolicyCatalog, PolicyCatalogFactory, PolicyContextBuilder, PolicyContextPath, PolicyDefinition, PolicyEvaluationErrors, PolicyHashing, PolicyKey, PolicyResolver, PolicyScopeMatcher, PolicyService, Query, RequestedBy, Result, RulesetRegistry, SerializationCodes, SerializationError, SerializationMessages, SerializationOutError, TemporalError, TemporalUseCase, UnexpectedError, UniqueConstraintViolationError, UseCase, UuidIdentifier, ValidationCode, ValidationError, ValidationException, ValidationField, ValueObject, asPolicyDecisionId, asPolicyDefinitionId, asSchoolId, asTenantId, assertJsonSafeMetadata, assertTemporalContext, buildDomainEventContractVersions, contextResolverRegistry, coreConfig, createDomainEventEnvelope, createTemporalContext, erpCoreRelease, evaluateTemporalWindow, mapPolicyEvaluationError, payloadHash, registerNamespacedContextResolvers, registerNamespacedContextResolversIn, safePreview, serializationErrorCode, sha256Hex, stableStringify, translateUniqueViolationToDuplicate, version };
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["version","version"],"sources":["../src/version.ts","../src/core/shared/aggregate-version.ts","../src/core/domain/entity.ts","../src/core/domain/value-object.ts","../src/index.ts"],"sourcesContent":["// Versao do kit, sincronizada com package.json por scripts/sync-kit-version.mjs.\n// Nao edite a mao: rode `npm run sync-kit-version` (ou e regenerado no release).\n//\n// Mantemos a versao aqui, dentro de src/, para que a copia full-control seja\n// auto-contida: ao copiar so o conteudo de src/, o entry nao depende de um\n// `../package.json` que deixaria de existir no projeto consumidor.\nexport const version = \"1.1.0\";\n","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 { type DeepReadonly, makeImmutable } from \"../shared/immutable.js\";\nimport { type ContractVersion, version } from \"../versioning/version.js\";\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    /** 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, subclasses implement equality over the wrapped data\n     * (typically the primitive form), so two independently constructed instances\n     * holding the same data are considered equal.\n     */\n    public abstract equals(other: this): boolean;\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 };\n","import { version } from \"./version.js\";\n\nexport * from \"./core/index.js\";\n\nexport const ERP_CORE_NAME = \"erp-core\";\nexport const ERP_CORE_VERSION = version;\n\nexport const erpCoreRelease = {\n    name: ERP_CORE_NAME,\n    version: ERP_CORE_VERSION,\n} as const;\n"],"mappings":";;;;;;;;;;;;AAMA,MAAa,UAAU;;;ACJvB,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;+BA7GCA,UAAQ,KAAK,CAAA,GAAA,MAAA;;;;;;;;;;;;;;;;;;;AChBd,IAAA,cAAA,MACe,YAAkB;;;;;;;;;CAW7B,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;AAeJ;yCA5DCC,UAAQ,KAAK,CAAA,GAAA,WAAA;;;ACdd,MAAa,gBAAgB;AAC7B,MAAa,mBAAmB;AAEhC,MAAa,iBAAiB;CAC1B,MAAM;CACN,SAAS;AACb"}
+{"version":3,"file":"index.js","names":["version","version"],"sources":["../src/version.ts","../src/index.ts"],"sourcesContent":["// Versao do kit, sincronizada com package.json por scripts/sync-kit-version.mjs.\n// Nao edite a mao: rode `npm run sync-kit-version` (ou e regenerado no release).\n//\n// Mantemos a versao aqui, dentro de src/, para que a copia full-control seja\n// auto-contida: ao copiar so o conteudo de src/, o entry nao depende de um\n// `../package.json` que deixaria de existir no projeto consumidor.\nexport const version = \"1.2.0\";\n","import { version } from \"./version.js\";\n\nexport * from \"./core/index.js\";\n\nexport const ERP_CORE_NAME = \"erp-core\";\nexport const ERP_CORE_VERSION = version;\n\nexport const erpCoreRelease = {\n    name: ERP_CORE_NAME,\n    version: ERP_CORE_VERSION,\n} as const;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAMA,MAAaA,YAAU;;;ACFvB,MAAa,gBAAgB;AAC7B,MAAa,mBAAmBC;AAEhC,MAAa,iBAAiB;CAC1B,MAAM;CACN,SAAS;AACb"}

package/dist/invalid-state-transition-exception.js

@@ -0,0 +1,30 @@
+import { t as DomainException } from "./domain-exception.js";
+//#region src/core/exceptions/business-rule-violation-exception.ts
+var BusinessRuleViolationException = class extends DomainException {
+	constructor(rule, message) {
+		super(message);
+		this.rule = rule;
+	}
+};
+//#endregion
+//#region src/core/exceptions/entity-not-found-exception.ts
+var EntityNotFoundException = class extends DomainException {
+	constructor(entityName, identifier) {
+		super(`${entityName} with identifier ${identifier} was not found.`);
+		this.entityName = entityName;
+		this.identifier = identifier;
+	}
+};
+//#endregion
+//#region src/core/exceptions/invalid-state-transition-exception.ts
+var InvalidStateTransitionException = class extends DomainException {
+	constructor(from, to, message) {
+		super(message);
+		this.from = from;
+		this.to = to;
+	}
+};
+//#endregion
+export { EntityNotFoundException as n, BusinessRuleViolationException as r, InvalidStateTransitionException as t };
+
+//# sourceMappingURL=invalid-state-transition-exception.js.map

package/dist/invalid-state-transition-exception.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalid-state-transition-exception.js","names":[],"sources":["../src/core/exceptions/business-rule-violation-exception.ts","../src/core/exceptions/entity-not-found-exception.ts","../src/core/exceptions/invalid-state-transition-exception.ts"],"sourcesContent":["import { DomainException } from \"./domain-exception.js\";\n\nclass BusinessRuleViolationException extends DomainException {\n    constructor(\n        public readonly rule: string,\n        message: string,\n    ) {\n        super(message);\n    }\n}\n\nexport { BusinessRuleViolationException };\n","import { DomainException } from \"./domain-exception.js\";\n\nclass EntityNotFoundException extends DomainException {\n    constructor(\n        public readonly entityName: string,\n        public readonly identifier: string,\n    ) {\n        super(`${entityName} with identifier ${identifier} was not found.`);\n    }\n}\n\nexport { EntityNotFoundException };\n","import { DomainException } from \"./domain-exception.js\";\n\nclass InvalidStateTransitionException<\n    TState extends string = string,\n> extends DomainException {\n    constructor(\n        public readonly from: TState,\n        public readonly to: TState,\n        message: string,\n    ) {\n        super(message);\n    }\n}\n\nexport { InvalidStateTransitionException };\n"],"mappings":";;AAEA,IAAM,iCAAN,cAA6C,gBAAgB;CACzD,YACI,MACA,SACF;EACE,MAAM,OAAO;EAHG,KAAA,OAAA;CAIpB;AACJ;;;ACPA,IAAM,0BAAN,cAAsC,gBAAgB;CAClD,YACI,YACA,YACF;EACE,MAAM,GAAG,WAAW,mBAAmB,WAAW,gBAAgB;EAHlD,KAAA,aAAA;EACA,KAAA,aAAA;CAGpB;AACJ;;;ACPA,IAAM,kCAAN,cAEU,gBAAgB;CACtB,YACI,MACA,IACA,SACF;EACE,MAAM,OAAO;EAJG,KAAA,OAAA;EACA,KAAA,KAAA;CAIpB;AACJ"}

package/dist/invariant-violation-exception.js

@@ -0,0 +1,11 @@
+import { t as DomainException } from "./domain-exception.js";
+//#region src/core/exceptions/invariant-violation-exception.ts
+var InvariantViolationException = class extends DomainException {
+	constructor(message) {
+		super(message);
+	}
+};
+//#endregion
+export { InvariantViolationException as t };
+
+//# sourceMappingURL=invariant-violation-exception.js.map

package/dist/invariant-violation-exception.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invariant-violation-exception.js","names":[],"sources":["../src/core/exceptions/invariant-violation-exception.ts"],"sourcesContent":["import { DomainException } from \"./domain-exception.js\";\n\nclass InvariantViolationException extends DomainException {\n    constructor(message: string) {\n        super(message);\n    }\n}\n\nexport { InvariantViolationException };\n"],"mappings":";;AAEA,IAAM,8BAAN,cAA0C,gBAAgB;CACtD,YAAY,SAAiB;EACzB,MAAM,OAAO;CACjB;AACJ"}

package/dist/not-found-error.js

@@ -1,4 +1,4 @@
-import { a as ErrorCodes, r as AppError } from "./validation-code.js";
+import { i as ErrorCodes, n as AppError } from "./unexpected-error.js";
 //#region src/core/errors/business-rule-violation-error.ts
 var BusinessRuleViolationError = class extends AppError {
 	constructor(rule, message, detail, options) {

package/dist/outcome.d.ts

@@ -0,0 +1,140 @@
+//#region src/core/result/result.d.ts
+/**
+ * Represents the outcome of an operation that may succeed or fail.
+ * Useful for avoiding excessive exceptions and making error flows explicit.
+ */
+declare abstract class Result<T, E> {
+  protected constructor();
+  /**
+   * Creates a success result containing a value.
+   */
+  static ok<T>(value: T): Result<T, never>;
+  /**
+   * Creates an error result containing an error object.
+   */
+  static err<E>(error: E): Result<never, E>;
+  /**
+   * Returns true when this is a success result.
+   */
+  abstract isOk(): this is Ok<T>;
+  /**
+   * Returns true when this is an error result.
+   */
+  abstract isErr(): this is Err<E>;
+  /**
+   * Runs a handler based on the result state (similar to pattern matching).
+   */
+  abstract match<R>(handlers: {
+    ok: (value: T) => R;
+    err: (error: E) => R;
+  }): R;
+  /**
+   * Returns the value when this is success, or null when this is an error.
+   */
+  getOrNull(): T | null;
+  /**
+   * Returns the error when this is a failure, or null when this is a success.
+   */
+  errorOrNull(): E | null;
+  /**
+   * Returns the value when this is a success, or throws the error when this is a failure.
+   */
+  getOrThrow(): T;
+  /**
+   * Transforms the success value using the provided function. Keeps the error when this is a failure.
+   */
+  map<R>(transform: (value: T) => R): Result<R, E>;
+  /**
+   * Transforms the error using the provided function. Keeps the value when this is a success.
+   */
+  mapError<F>(transform: (error: E) => F): Result<T, F>;
+  /**
+   * Chains another operation that returns a Result when this result is a success.
+   */
+  flatMap<R>(transform: (value: T) => Result<R, E>): Result<R, E>;
+}
+/**
+ * Success variant of Result.
+ */
+declare class Ok<T> extends Result<T, never> {
+  readonly value: T;
+  constructor(value: T);
+  isOk(): this is Ok<T>;
+  isErr(): this is Err<never>;
+  match<R>(handlers: {
+    ok: (value: T) => R;
+    err: (error: never) => R;
+  }): R;
+}
+/**
+ * Error variant of Result.
+ */
+declare class Err<E> extends Result<never, E> {
+  readonly error: E;
+  constructor(error: E);
+  isOk(): this is Ok<never>;
+  isErr(): this is Err<E>;
+  match<R>(handlers: {
+    ok: (value: never) => R;
+    err: (error: E) => R;
+  }): R;
+}
+//#endregion
+//#region src/core/result/outcome.d.ts
+/**
+ * Outcome — Business decision abstraction.
+ *
+ * Represents the semantic result of a domain decision, policy evaluation,
+ * or business rule. NOT for technical success/failure — use Result for that.
+ *
+ * Mental model:
+ *   "What was the business decision?"
+ *   NOT "Did the operation succeed?"
+ *
+ * The status axis represents valid business outcomes (APPROVED, REJECTED,
+ * ALLOW, DENY, NO_OP, etc.), never technical Ok/Err.
+ *
+ * @typeParam S - Union of valid status literals for this outcome
+ * @typeParam D - Shape of the decision data carried by this outcome
+ */
+declare class Outcome<S extends string, D = undefined> {
+  readonly status: S;
+  readonly data: D;
+  readonly reason: string | undefined;
+  readonly metadata: Readonly<Record<string, unknown>>;
+  private constructor();
+  static of<S extends string, D = undefined>(status: S, data: D, reason?: string, metadata?: Record<string, unknown>): Outcome<S, D>;
+  static approved<D = undefined>(data: D, reason?: string): Outcome<"APPROVED", D>;
+  static rejected<D = undefined>(data: D, reason: string): Outcome<"REJECTED", D>;
+  static noOp<D = undefined>(data: D, reason?: string): Outcome<"NO_OP", D>;
+  static deferred<D = undefined>(data: D, reason: string): Outcome<"DEFERRED", D>;
+  static requiresReview<D = undefined>(data: D, reason: string): Outcome<"REQUIRES_REVIEW", D>;
+  /**
+   * Narrows this Outcome to a specific status.
+   *
+   * @example
+   * if (outcome.is('DENY')) {
+   *   outcome.data.violations // TS knows status is 'DENY'
+   * }
+   */
+  is<T extends S>(status: T): this is Outcome<T, D>;
+  /**
+   * Exhaustive pattern match over all possible statuses.
+   * TypeScript enforces that every status has a handler.
+   *
+   * @example
+   * outcome.match({
+   *   ALLOW: (o) => handleAllow(o.data),
+   *   DENY:  (o) => handleDeny(o.data.violations),
+   * })
+   */
+  match<THandlers extends { [K in S]: (outcome: Outcome<K, D>) => unknown }>(handlers: THandlers): ReturnType<THandlers[S]>;
+  withMetadata(extra: Record<string, unknown>): Outcome<S, D>;
+  withReason(reason: string): Outcome<S, D>;
+  toString(): string;
+}
+/** Common business outcome statuses. Extend per domain as needed. */
+type CommonOutcomeStatus = "APPROVED" | "REJECTED" | "NO_OP" | "DEFERRED" | "REQUIRES_REVIEW";
+//#endregion
+export { Result as a, Ok as i, Outcome as n, Err as r, CommonOutcomeStatus as t };
+//# sourceMappingURL=outcome.d.ts.map

package/dist/outcome.js

@@ -1,4 +1,4 @@
-import { i as InvariantViolationException } from "./temporal-guards.js";
+import { t as InvariantViolationException } from "./invariant-violation-exception.js";
 //#region src/core/result/outcome.ts
 /**
 * Outcome — Business decision abstraction.

package/dist/parse-gate-payload.d.ts

@@ -1,4 +1,5 @@
-import { I as Result, d as GatePayloadV1, s as PolicyContext, u as GatePayload } from "./gate-types.js";
+import { a as Result } from "./outcome.js";
+import { d as GatePayloadV1, s as PolicyContext, u as GatePayload } from "./gate-types.js";
 import { a as ComputeOutcome, c as VersionedComputeEngine, i as ComputeEvaluatorRegistration, l as ComputePayload, p as ComputePayloadV1, r as ComputeEvaluator } from "./gate-engine-registry.js";
 
 //#region src/core/policies/engines/compute-evaluator-registry.d.ts

package/dist/path.d.ts

@@ -1,4 +1,5 @@
-import { I as Result, g as CoreConfig } from "./gate-types.js";
+import { a as Result } from "./outcome.js";
+import { m as CoreConfig } from "./gate-types.js";
 import { D as PolicyDefinition, N as PolicyCatalog, P as PolicyCatalogEntryProps, S as PolicyDefinitionRepository, T as FindCandidatesParams, m as ContextResolverRegistry, y as ContextValueResolver } from "./policy-service.js";
 import { i as ComputeEvaluatorRegistration } from "./gate-engine-registry.js";
 

package/dist/plugin.d.ts

@@ -0,0 +1,85 @@
+//#region src/core/plugins/types.d.ts
+/**
+ * Common shape every plugin shares, regardless of the contract it implements.
+ * Carries the metadata the {@link PluginManager} uses to identify, order and
+ * toggle plugins.
+ */
+interface BasePlugin {
+  /** Unique identifier, used for logs / debugging and for enable/disable. */
+  readonly name: string;
+  /** Weight; the highest priority wins (default = 0). */
+  readonly priority?: number;
+  /** Shortcut to disable a plugin without removing it. */
+  enabled?: boolean;
+}
+/**
+ * A plugin contract is a record whose values are the methods plugins may
+ * implement for a given extension point.
+ *
+ * `any` here is intentional: it is the only way to express the constraint
+ * "a record whose values are arbitrary functions". Using `unknown` for the
+ * parameters breaks assignment of concrete contracts by contravariance —
+ * TypeScript rejects functions with specific parameters as a subtype of
+ * `(...args: unknown[]) => unknown`.
+ */
+type PluginContract = Record<string, (...args: any[]) => any>;
+/**
+ * Reducer used in `pipeline` mode to combine the result of each plugin into a
+ * single accumulated value.
+ */
+type PipelineReducer<R, P extends PluginContract> = (accumulated: R, current: R, plugin: P & BasePlugin, index: number) => R;
+/** Options accepted by {@link PluginManager.invoke}. */
+interface InvokeOptions<P extends PluginContract, K extends keyof P> {
+  /**
+   * `'first'`    → returns the first enabled plugin with the highest priority.
+   * `'pipeline'` → runs every enabled plugin, combining results via `reducer`.
+   * default = `'first'`.
+   */
+  mode?: "first" | "pipeline";
+  /** Executed when no plugin is enabled for the method. */
+  fallback: P[K];
+  /** Reducer used only when `mode = "pipeline"`. */
+  reducer?: PipelineReducer<ReturnType<P[K]>, P>;
+}
+//#endregion
+//#region src/core/plugins/plugin.d.ts
+/**
+ * Registry that holds a set of plugins implementing a shared {@link PluginContract}
+ * and resolves which of them answer a given extension point.
+ *
+ * Plugins are kept sorted by priority (descending). For a given method,
+ * {@link invoke} either delegates to the highest-priority enabled plugin
+ * (`'first'`) or folds every enabled plugin into a single value (`'pipeline'`).
+ * When no plugin is enabled, the supplied `fallback` runs instead, so the host
+ * always has defined behaviour even with an empty registry.
+ *
+ * @typeParam P - The plugin contract this manager coordinates.
+ */
+declare class PluginManager<P extends PluginContract> {
+  /** Internal list, kept sorted by priority (desc). */
+  private plugins;
+  /** Registers one or more plugins and re-sorts by priority. */
+  register(...plugins: (P & BasePlugin)[]): void;
+  /** Removes a previously registered plugin by name. */
+  unregister(name: string): void;
+  /** Enables a registered plugin by name. */
+  enable(name: string): void;
+  /** Disables a registered plugin by name (without removing it). */
+  disable(name: string): void;
+  /** Lists enabled plugins only, already in priority order. */
+  list(): readonly (P & BasePlugin)[];
+  /**
+   * Resolves `method` against the registered plugins.
+   *
+   * In `'first'` mode the highest-priority enabled plugin that implements
+   * `method` answers. In `'pipeline'` mode every enabled plugin runs and the
+   * results are folded with `reducer` (defaults to "keep the last result").
+   * When no enabled plugin implements `method`, `fallback` is called.
+   */
+  invoke<K extends keyof P>(method: K, args: Parameters<P[K]>, opts: InvokeOptions<P, K>): ReturnType<P[K]>;
+  /** Re-sorts the internal list by priority (desc; default priority = 0). */
+  private reorder;
+}
+//#endregion
+export { PluginContract as a, PipelineReducer as i, BasePlugin as n, InvokeOptions as r, PluginManager as t };
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.js

@@ -0,0 +1,74 @@
+//#region src/core/plugins/plugin.ts
+/**
+* Registry that holds a set of plugins implementing a shared {@link PluginContract}
+* and resolves which of them answer a given extension point.
+*
+* Plugins are kept sorted by priority (descending). For a given method,
+* {@link invoke} either delegates to the highest-priority enabled plugin
+* (`'first'`) or folds every enabled plugin into a single value (`'pipeline'`).
+* When no plugin is enabled, the supplied `fallback` runs instead, so the host
+* always has defined behaviour even with an empty registry.
+*
+* @typeParam P - The plugin contract this manager coordinates.
+*/
+var PluginManager = class {
+	constructor() {
+		this.plugins = [];
+	}
+	/** Registers one or more plugins and re-sorts by priority. */
+	register(...plugins) {
+		this.plugins.push(...plugins);
+		this.reorder();
+	}
+	/** Removes a previously registered plugin by name. */
+	unregister(name) {
+		this.plugins = this.plugins.filter((p) => p.name !== name);
+	}
+	/** Enables a registered plugin by name. */
+	enable(name) {
+		const plugin = this.plugins.find((p) => p.name === name);
+		if (plugin) plugin.enabled = true;
+	}
+	/** Disables a registered plugin by name (without removing it). */
+	disable(name) {
+		const plugin = this.plugins.find((p) => p.name === name);
+		if (plugin) plugin.enabled = false;
+	}
+	/** Lists enabled plugins only, already in priority order. */
+	list() {
+		return this.plugins.filter((p) => p.enabled !== false);
+	}
+	/**
+	* Resolves `method` against the registered plugins.
+	*
+	* In `'first'` mode the highest-priority enabled plugin that implements
+	* `method` answers. In `'pipeline'` mode every enabled plugin runs and the
+	* results are folded with `reducer` (defaults to "keep the last result").
+	* When no enabled plugin implements `method`, `fallback` is called.
+	*/
+	invoke(method, args, opts) {
+		const { mode = "first", fallback, reducer } = opts;
+		const enabled = this.list().filter((p) => method in p);
+		if (enabled.length === 0) return fallback(...args);
+		if (mode === "first") {
+			const fn = enabled[0][method];
+			return fn(...args);
+		}
+		const defaultReducer = (_, curr) => curr;
+		const red = reducer ?? defaultReducer;
+		let acc = enabled[0][method](...args);
+		enabled.slice(1).forEach((plugin, idx) => {
+			const res = plugin[method](...args);
+			acc = red(acc, res, plugin, idx + 1);
+		});
+		return acc;
+	}
+	/** Re-sorts the internal list by priority (desc; default priority = 0). */
+	reorder() {
+		this.plugins.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+	}
+};
+//#endregion
+export { PluginManager as t };
+
+//# sourceMappingURL=plugin.js.map

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","names":[],"sources":["../src/core/plugins/plugin.ts"],"sourcesContent":["import {\n    type BasePlugin,\n    type InvokeOptions,\n    type PipelineReducer,\n    type PluginContract,\n} from \"./types.js\";\n\n/**\n * Registry that holds a set of plugins implementing a shared {@link PluginContract}\n * and resolves which of them answer a given extension point.\n *\n * Plugins are kept sorted by priority (descending). For a given method,\n * {@link invoke} either delegates to the highest-priority enabled plugin\n * (`'first'`) or folds every enabled plugin into a single value (`'pipeline'`).\n * When no plugin is enabled, the supplied `fallback` runs instead, so the host\n * always has defined behaviour even with an empty registry.\n *\n * @typeParam P - The plugin contract this manager coordinates.\n */\nclass PluginManager<P extends PluginContract> {\n    /** Internal list, kept sorted by priority (desc). */\n    private plugins: (P & BasePlugin)[] = [];\n\n    /** Registers one or more plugins and re-sorts by priority. */\n    public register(...plugins: (P & BasePlugin)[]): void {\n        this.plugins.push(...plugins);\n        this.reorder();\n    }\n\n    /** Removes a previously registered plugin by name. */\n    public unregister(name: string): void {\n        this.plugins = this.plugins.filter((p) => p.name !== name);\n    }\n\n    /** Enables a registered plugin by name. */\n    public enable(name: string): void {\n        const plugin = this.plugins.find((p) => p.name === name);\n        if (plugin) plugin.enabled = true;\n    }\n\n    /** Disables a registered plugin by name (without removing it). */\n    public disable(name: string): void {\n        const plugin = this.plugins.find((p) => p.name === name);\n        if (plugin) plugin.enabled = false;\n    }\n\n    /** Lists enabled plugins only, already in priority order. */\n    public list(): readonly (P & BasePlugin)[] {\n        return this.plugins.filter((p) => p.enabled !== false);\n    }\n\n    /**\n     * Resolves `method` against the registered plugins.\n     *\n     * In `'first'` mode the highest-priority enabled plugin that implements\n     * `method` answers. In `'pipeline'` mode every enabled plugin runs and the\n     * results are folded with `reducer` (defaults to \"keep the last result\").\n     * When no enabled plugin implements `method`, `fallback` is called.\n     */\n    public invoke<K extends keyof P>(\n        method: K,\n        args: Parameters<P[K]>,\n        opts: InvokeOptions<P, K>,\n    ): ReturnType<P[K]> {\n        const { mode = \"first\", fallback, reducer } = opts;\n        const enabled = this.list().filter((p) => method in p) as Array<\n            P & BasePlugin\n        >;\n\n        if (enabled.length === 0) {\n            return (fallback as P[K])(...args);\n        }\n\n        if (mode === \"first\") {\n            const fn = enabled[0][method] as P[K];\n            return fn(...args);\n        }\n\n        const defaultReducer: PipelineReducer<ReturnType<P[K]>, P> = (\n            _,\n            curr,\n        ) => curr;\n        const red = reducer ?? defaultReducer;\n\n        let acc: ReturnType<P[K]> = enabled[0][method]!(...args);\n        enabled.slice(1).forEach((plugin, idx) => {\n            const res = plugin[method]!(...args);\n            acc = red(acc, res, plugin, idx + 1);\n        });\n        return acc;\n    }\n\n    /** Re-sorts the internal list by priority (desc; default priority = 0). */\n    private reorder(): void {\n        this.plugins.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));\n    }\n}\n\nexport { PluginManager };\n"],"mappings":";;;;;;;;;;;;;AAmBA,IAAM,gBAAN,MAA8C;;iBAEJ,CAAC;;;CAGvC,SAAgB,GAAG,SAAmC;EAClD,KAAK,QAAQ,KAAK,GAAG,OAAO;EAC5B,KAAK,QAAQ;CACjB;;CAGA,WAAkB,MAAoB;EAClC,KAAK,UAAU,KAAK,QAAQ,QAAQ,MAAM,EAAE,SAAS,IAAI;CAC7D;;CAGA,OAAc,MAAoB;EAC9B,MAAM,SAAS,KAAK,QAAQ,MAAM,MAAM,EAAE,SAAS,IAAI;EACvD,IAAI,QAAQ,OAAO,UAAU;CACjC;;CAGA,QAAe,MAAoB;EAC/B,MAAM,SAAS,KAAK,QAAQ,MAAM,MAAM,EAAE,SAAS,IAAI;EACvD,IAAI,QAAQ,OAAO,UAAU;CACjC;;CAGA,OAA2C;EACvC,OAAO,KAAK,QAAQ,QAAQ,MAAM,EAAE,YAAY,KAAK;CACzD;;;;;;;;;CAUA,OACI,QACA,MACA,MACgB;EAChB,MAAM,EAAE,OAAO,SAAS,UAAU,YAAY;EAC9C,MAAM,UAAU,KAAK,KAAK,EAAE,QAAQ,MAAM,UAAU,CAAC;EAIrD,IAAI,QAAQ,WAAW,GACnB,OAAQ,SAAkB,GAAG,IAAI;EAGrC,IAAI,SAAS,SAAS;GAClB,MAAM,KAAK,QAAQ,GAAG;GACtB,OAAO,GAAG,GAAG,IAAI;EACrB;EAEA,MAAM,kBACF,GACA,SACC;EACL,MAAM,MAAM,WAAW;EAEvB,IAAI,MAAwB,QAAQ,GAAG,QAAS,GAAG,IAAI;EACvD,QAAQ,MAAM,CAAC,EAAE,SAAS,QAAQ,QAAQ;GACtC,MAAM,MAAM,OAAO,QAAS,GAAG,IAAI;GACnC,MAAM,IAAI,KAAK,KAAK,QAAQ,MAAM,CAAC;EACvC,CAAC;EACD,OAAO;CACX;;CAGA,UAAwB;EACpB,KAAK,QAAQ,MAAM,GAAG,OAAO,EAAE,YAAY,MAAM,EAAE,YAAY,EAAE;CACrE;AACJ"}