@cullet/erp-core 1.0.11 → 1.2.0

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["version","version"],"sources":["../src/version.ts","../src/core/application/policy-error-mapper.ts","../src/core/shared/aggregate-version.ts","../src/core/versioning/version.ts","../src/core/domain/entity.ts","../src/core/shared/immutable.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.0.11\";\n","import {\n    type AppError,\n    BusinessRuleViolationError,\n    NotFoundError,\n    UnexpectedError,\n} from \"../errors/index.js\";\nimport type { PolicyEvaluationError } from \"../policies/index.js\";\n\nexport function mapPolicyEvaluationError(err: PolicyEvaluationError): AppError {\n    switch (err.kind) {\n        case \"INVALID_CONTEXT\":\n            return new BusinessRuleViolationError(\n                `policy.${err.stage.toLowerCase()}`,\n                err.message,\n                { policyKey: err.policyKey, stage: err.stage },\n                { cause: err.cause },\n            );\n        case \"INVALID_POLICY_KEY\":\n            return new BusinessRuleViolationError(\n                \"policy.invalid_key\",\n                err.message,\n                { rawPolicyKey: err.rawPolicyKey },\n                { cause: err.cause },\n            );\n        case \"POLICY_NOT_FOUND\":\n            return new NotFoundError(\n                \"Policy\",\n                { policyKey: err.policyKey },\n                { cause: err.cause },\n            );\n        case \"POLICY_DEFINITION_NOT_FOUND\":\n            return new NotFoundError(\n                \"PolicyDefinition\",\n                {\n                    policyKey: err.policyKey,\n                    contextVersion: err.contextVersion,\n                    asOf: err.asOf.toISOString(),\n                },\n                { cause: err.cause },\n            );\n        case \"POLICY_VARIANT_NOT_FOUND\":\n            return new NotFoundError(\n                \"PolicyVariant\",\n                {\n                    policyKey: err.policyKey,\n                    policyKind: err.policyKind,\n                    payloadSchemaVersion: err.payloadSchemaVersion,\n                },\n                { cause: err.cause },\n            );\n        case \"ENGINE_FAILURE\":\n            return new UnexpectedError(err.message, err.cause, {\n                metadata: {\n                    policyKey: err.policyKey,\n                    engine: err.engine,\n                    engineVersion: err.engineVersion,\n                },\n            });\n    }\n}\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","type ContractVersion = `${number}.${number}`;\n\ntype VersionedTarget = {\n    readonly prototype: object;\n};\n\nconst CONTRACT_VERSION_PROPERTY = \"CONTRACT_VERSION\" as const;\nconst CONTRACT_VERSION_PATTERN = /^\\d+\\.\\d+$/;\n\nfunction version<const TVersion extends ContractVersion>(\n    contractVersion: TVersion,\n) {\n    if (!CONTRACT_VERSION_PATTERN.test(contractVersion)) {\n        throw new TypeError(\n            `Invalid contract version \"${contractVersion}\". Expected MAJOR.MINOR.`,\n        );\n    }\n\n    return (target: VersionedTarget): void => {\n        Object.defineProperty(target, CONTRACT_VERSION_PROPERTY, {\n            value: contractVersion,\n            writable: false,\n            configurable: false,\n            enumerable: false,\n        });\n    };\n}\n\nexport {\n    CONTRACT_VERSION_PROPERTY,\n    type ContractVersion,\n    version,\n    type VersionedTarget,\n};\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 { InvariantViolationException } from \"../exceptions/invariant-violation-exception.js\";\n\ntype PrimitiveValue =\n    | bigint\n    | boolean\n    | null\n    | number\n    | string\n    | symbol\n    | undefined;\n\ntype DeepReadonly<T> = T extends PrimitiveValue | Date\n    ? T\n    : T extends readonly (infer TItem)[]\n      ? readonly DeepReadonly<TItem>[]\n      : { readonly [TKey in keyof T]: DeepReadonly<T[TKey]> };\n\nfunction deepFreeze<T>(value: T): T {\n    return deepFreezeInternal(value, new WeakSet<object>());\n}\n\nfunction deepFreezeInternal<T>(value: T, seen: WeakSet<object>): T {\n    // Primitives and `null` need no freezing. `Date` is intentionally returned\n    // as-is: `Object.freeze` cannot stop a Date's mutators (`setTime`,\n    // `setFullYear`, …) because they write an internal slot, not an own\n    // property — freezing it is a no-op against mutation. `makeImmutable`\n    // already hands us a `structuredClone` copy, so the caller's original Date\n    // is never aliased; deep-freezing of nested Dates is deliberately skipped.\n    if (typeof value !== \"object\" || value === null || value instanceof Date) {\n        return value;\n    }\n\n    // A value already on `seen` has been visited on this pass (cyclic graph or a\n    // shared reference); revisiting it would recurse forever.\n    if (seen.has(value)) {\n        return value;\n    }\n    seen.add(value);\n\n    if (Array.isArray(value)) {\n        for (const item of value) {\n            deepFreezeInternal(item, seen);\n        }\n\n        return Object.freeze(value);\n    }\n\n    const objectValue = value as Record<PropertyKey, object | PrimitiveValue>;\n\n    for (const propertyKey of Reflect.ownKeys(objectValue)) {\n        deepFreezeInternal(objectValue[propertyKey], seen);\n    }\n\n    return Object.freeze(value);\n}\n\nfunction makeImmutable<T>(value: T): DeepReadonly<T> {\n    if (typeof value !== \"object\" || value === null) {\n        return value as DeepReadonly<T>;\n    }\n\n    let snapshot: T;\n    try {\n        snapshot = structuredClone(value);\n    } catch (error) {\n        // `structuredClone` throws `DataCloneError` for functions, symbols and\n        // class instances. Surface it as a domain invariant instead of leaking\n        // a host-specific runtime error to callers building value objects.\n        throw new InvariantViolationException(\n            `makeImmutable requires a structured-cloneable value: ${\n                error instanceof Error ? error.message : String(error)\n            }`,\n        );\n    }\n\n    return deepFreeze(snapshot) as DeepReadonly<T>;\n}\n\nexport { deepFreeze, makeImmutable, type DeepReadonly };\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":"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"}
+{"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

@@ -0,0 +1,54 @@
+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) {
+		const baseMetadata = detail ? {
+			rule,
+			detail
+		} : { rule };
+		const mergedMetadata = options?.metadata ? {
+			...baseMetadata,
+			...options.metadata
+		} : baseMetadata;
+		super(message, ErrorCodes.businessRuleViolation, {
+			...options,
+			metadata: mergedMetadata
+		});
+	}
+};
+//#endregion
+//#region src/core/errors/not-found-error.ts
+/**
+* Raised when a requested resource does not exist. Maps naturally onto an HTTP
+* 404 at the edge, but stays transport-agnostic here.
+*
+* The `resource` name builds the message (`"<resource> not found"`) and, with
+* the optional lookup `criteria`, lands in the metadata so logs show *what* was
+* searched for without the caller having to restate it in the message.
+*/
+var NotFoundError = class extends AppError {
+	/**
+	* @param resource - Human-readable name of the missing resource (e.g. `"Order"`).
+	* @param criteria - Optional lookup keys used in the search; recorded in
+	*   metadata to aid debugging. Avoid putting sensitive values here.
+	* @param options - Optional cause, correlation ids, and extra metadata.
+	*/
+	constructor(resource, criteria, options) {
+		const baseMetadata = criteria ? {
+			resource,
+			criteria
+		} : { resource };
+		const mergedMetadata = options?.metadata ? {
+			...baseMetadata,
+			...options.metadata
+		} : baseMetadata;
+		super(`${resource} not found`, ErrorCodes.notFound, {
+			...options,
+			metadata: mergedMetadata
+		});
+	}
+};
+//#endregion
+export { BusinessRuleViolationError as n, NotFoundError as t };
+
+//# sourceMappingURL=not-found-error.js.map

package/dist/not-found-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"not-found-error.js","names":[],"sources":["../src/core/errors/business-rule-violation-error.ts","../src/core/errors/not-found-error.ts"],"sourcesContent":["import { AppError } from \"./app-error.js\";\nimport { ErrorCodes } from \"./error-codes.js\";\nimport type { AppErrorOptions } from \"./types.js\";\n\n// ─────────────────────────────────────────────────────────────────────────────\n// BusinessRuleViolationError\n// ─────────────────────────────────────────────────────────────────────────────\n\nclass BusinessRuleViolationError extends AppError {\n    constructor(\n        rule: string,\n        message: string,\n        detail?: Record<string, unknown>,\n        options?: AppErrorOptions,\n    ) {\n        const baseMetadata = detail ? { rule, detail } : { rule };\n        const mergedMetadata = options?.metadata\n            ? { ...baseMetadata, ...options.metadata }\n            : baseMetadata;\n\n        super(message, ErrorCodes.businessRuleViolation, {\n            ...options,\n            metadata: mergedMetadata,\n        });\n    }\n}\n\nexport { BusinessRuleViolationError };\n","import { AppError } from \"./app-error.js\";\nimport { ErrorCodes } from \"./error-codes.js\";\nimport type { AppErrorOptions } from \"./types.js\";\n\n// ─────────────────────────────────────────────────────────────────────────────\n// NotFoundError\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Raised when a requested resource does not exist. Maps naturally onto an HTTP\n * 404 at the edge, but stays transport-agnostic here.\n *\n * The `resource` name builds the message (`\"<resource> not found\"`) and, with\n * the optional lookup `criteria`, lands in the metadata so logs show *what* was\n * searched for without the caller having to restate it in the message.\n */\nclass NotFoundError extends AppError {\n    /**\n     * @param resource - Human-readable name of the missing resource (e.g. `\"Order\"`).\n     * @param criteria - Optional lookup keys used in the search; recorded in\n     *   metadata to aid debugging. Avoid putting sensitive values here.\n     * @param options - Optional cause, correlation ids, and extra metadata.\n     */\n    constructor(\n        resource: string,\n        criteria?: Record<string, unknown>,\n        options?: AppErrorOptions,\n    ) {\n        const baseMetadata = criteria ? { resource, criteria } : { resource };\n        const mergedMetadata = options?.metadata\n            ? { ...baseMetadata, ...options.metadata }\n            : baseMetadata;\n\n        super(`${resource} not found`, ErrorCodes.notFound, {\n            ...options,\n            metadata: mergedMetadata,\n        });\n    }\n}\n\nexport { NotFoundError };\n"],"mappings":";;AAQA,IAAM,6BAAN,cAAyC,SAAS;CAC9C,YACI,MACA,SACA,QACA,SACF;EACE,MAAM,eAAe,SAAS;GAAE;GAAM;EAAO,IAAI,EAAE,KAAK;EACxD,MAAM,iBAAiB,SAAS,WAC1B;GAAE,GAAG;GAAc,GAAG,QAAQ;EAAS,IACvC;EAEN,MAAM,SAAS,WAAW,uBAAuB;GAC7C,GAAG;GACH,UAAU;EACd,CAAC;CACL;AACJ;;;;;;;;;;;ACTA,IAAM,gBAAN,cAA4B,SAAS;;;;;;;CAOjC,YACI,UACA,UACA,SACF;EACE,MAAM,eAAe,WAAW;GAAE;GAAU;EAAS,IAAI,EAAE,SAAS;EACpE,MAAM,iBAAiB,SAAS,WAC1B;GAAE,GAAG;GAAc,GAAG,QAAQ;EAAS,IACvC;EAEN,MAAM,GAAG,SAAS,aAAa,WAAW,UAAU;GAChD,GAAG;GACH,UAAU;EACd,CAAC;CACL;AACJ"}

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 { g as InvariantViolationException } from "./gate-v1-payload.schema.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,58 +1,7 @@
-import { I as Result, c as PolicyViolation, d as GatePayloadV1, g as CoreConfig, h as Outcome, l as VersionedGateEngine, p as ConditionNode, s as PolicyContext, t as GateOutcome, u as GatePayload } from "./gate-types.js";
-import { z } from "zod";
+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/v1/compute/compute-payload.schema.d.ts
-interface ComputeParamsPayload {
-  readonly type: "params";
-  readonly data: Readonly<Record<string, unknown>>;
-}
-interface ComputeDecisionTableRule<R = unknown> {
-  readonly conditions: ConditionNode;
-  readonly result: R;
-}
-interface ComputeDecisionTablePayload<R = unknown> {
-  readonly type: "decision-table";
-  readonly rules: readonly ComputeDecisionTableRule<R>[];
-  readonly default: R;
-}
-type ComputePayloadV1 = ComputeDecisionTablePayload<unknown> | ComputeParamsPayload;
-//#endregion
-//#region src/core/policies/engines/compute-payload.d.ts
-type ComputePayload = ComputePayloadV1;
-//#endregion
-//#region src/core/policies/engines/compute-types.d.ts
-type ComputeStatus = "OK" | "NOT_APPLICABLE" | "ERROR";
-interface ComputeOutcomeData {
-  readonly values: unknown | null;
-  readonly violations: readonly PolicyViolation[];
-}
-/** Semantic outcome of a COMPUTE policy evaluation. */
-type ComputeOutcome = Outcome<ComputeStatus, ComputeOutcomeData>;
-/**
- * Pure compute operation: receives a resolved value + context, returns a
- * business decision. Registration metadata (policy key/version) lives outside
- * this contract.
- *
- * The engine resolves the structural payload before calling the evaluator:
- * - `params` -> `payload.data`
- * - `decision-table` -> matching `rule.result` or `default`
- *
- * Result wraps technical failures (invalid value shape).
- * Outcome carries the semantic business decision.
- */
-interface ComputeEvaluator {
-  evaluate(resolvedValue: unknown, context: Record<string, unknown>): Result<ComputeOutcome, string>;
-}
-interface ComputeEvaluatorRegistration {
-  readonly policyKey: string;
-  readonly version: number;
-  readonly evaluator: ComputeEvaluator;
-}
-interface VersionedComputeEngine {
-  readonly version: number;
-  evaluate(payload: ComputePayload, context: PolicyContext, evaluator: ComputeEvaluator): Result<ComputeOutcome, string>;
-}
-//#endregion
 //#region src/core/policies/engines/compute-evaluator-registry.d.ts
 declare class ComputeEvaluatorRegistry {
   private readonly evaluators;
@@ -75,29 +24,6 @@ declare class ComputeEngineRegistry {
   }): Result<ComputeOutcome, string>;
 }
 //#endregion
-//#region src/core/policies/engines/compute-registry.d.ts
-interface ComputeRegistryOptions {
-  readonly coreConfig?: CoreConfig;
-}
-declare class ComputeRegistry {
-  private readonly engines;
-  private readonly evaluators;
-  constructor(params?: ComputeRegistryOptions);
-  register(registration: ComputeEvaluatorRegistration): void;
-  registerEngine(engine: VersionedComputeEngine): void;
-  getEngine(version: number): VersionedComputeEngine | undefined;
-  getEvaluator(policyKey: string, version: number): ComputeEvaluator | undefined;
-  evaluate(policyKey: string, computeEngineVersion: number, payloadSchemaVersion: number, payload: unknown, context: PolicyContext): Result<ComputeOutcome, string>;
-}
-//#endregion
-//#region src/core/policies/engines/gate-engine-registry.d.ts
-declare class GateEngineRegistry {
-  private readonly engines;
-  register(engine: VersionedGateEngine): void;
-  get(version: number): VersionedGateEngine | undefined;
-  evaluate(version: number, payload: unknown, context: PolicyContext): Result<GateOutcome, string>;
-}
-//#endregion
 //#region src/core/policies/engines/parse-compute-payload.d.ts
 type ComputePayloadParser = (payload: unknown) => Result<ComputePayload, string>;
 declare class ComputePayloadParserRegistry {
@@ -132,5 +58,5 @@ declare class GatePayloadParsers {
   static parse(engineVersion: number, payload: unknown): Result<GatePayloadV1, string>;
 }
 //#endregion
-export { ComputePayload as _, ComputePayloadParserRegistry as a, ComputeParamsPayload as b, ComputeRegistry as c, ComputeEvaluator as d, ComputeEvaluatorRegistration as f, VersionedComputeEngine as g, ComputeStatus as h, ComputePayloadParser as i, ComputeEngineRegistry as l, ComputeOutcomeData as m, GatePayloadParserRegistry as n, ComputePayloadParsers as o, ComputeOutcome as p, GatePayloadParsers as r, GateEngineRegistry as s, GatePayloadParser as t, ComputeEvaluatorRegistry as u, ComputeDecisionTablePayload as v, ComputePayloadV1 as x, ComputeDecisionTableRule as y };
+export { ComputePayloadParserRegistry as a, ComputeEvaluatorRegistry as c, ComputePayloadParser as i, GatePayloadParserRegistry as n, ComputePayloadParsers as o, GatePayloadParsers as r, ComputeEngineRegistry as s, GatePayloadParser as t };
 //# sourceMappingURL=parse-gate-payload.d.ts.map

package/dist/path.d.ts

@@ -0,0 +1,90 @@
+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";
+
+//#region src/core/config/core-config.instance.d.ts
+
+/**
+ * Shared instance for the application composition root.
+ * Use `new CoreConfig()` for isolated runtimes, tests, or multi-tenant hosts.
+ *
+ * The default reporter is silent so the core has no runtime logging dependency.
+ * Hosts can swap in their own `PolicyReporter` via
+ * `coreConfig.configure({ observability: { reporter } })`.
+ */
+declare const coreConfig: CoreConfig;
+//#endregion
+//#region src/core/policies/utils/hash.d.ts
+/**
+ * Produces a deterministic SHA-256 hex digest of a canonical JSON representation.
+ * Object keys are sorted recursively so key order does not affect the hash.
+ * Array item order is preserved on purpose; callers that treat arrays as sets
+ * must normalize or sort them before hashing.
+ *
+ * Values that JSON.stringify would silently drop or coerce (undefined,
+ * non-finite numbers, functions, symbols, bigint) are rejected up-front to
+ * prevent semantically different payloads from collapsing to the same hash.
+ */
+declare class PolicyHashing {
+  static sha256(input: string): string;
+  private static assertHashable;
+  static canonicalJson(value: unknown): string;
+  static computePayloadHash(payload: unknown, policyKey: string, policyVersion: string): string;
+}
+//#endregion
+//#region src/core/policies/defs/in-memory-policy-definition-repo.d.ts
+declare class InMemoryPolicyDefinitionRepository implements PolicyDefinitionRepository {
+  private readonly definitions;
+  private readonly definitionsByPolicyKey;
+  constructor(definitions: readonly PolicyDefinition[]);
+  findCandidates(params: FindCandidatesParams): PolicyDefinition[];
+}
+//#endregion
+//#region src/core/policies/package/policy-package.d.ts
+/**
+ * Protocol of contribution: a module declares what it wants to add to the
+ * policy system without the core knowing which module it is.
+ *
+ * - catalogEntries: static policy descriptors the catalog will register.
+ * - definitions:   default policy definitions (rules/parameters) to seed.
+ * - evaluators:    compute evaluator registrations keyed by policy/version.
+ */
+interface PolicyPackage {
+  readonly catalogEntries: readonly PolicyCatalogEntryProps[];
+  readonly definitions: readonly PolicyDefinition[];
+  readonly evaluators: readonly ComputeEvaluatorRegistration[];
+}
+//#endregion
+//#region src/core/policies/catalog/catalog.instance.d.ts
+/**
+ * Aggregates catalog entries contributed by each module package into a single
+ * PolicyCatalog. The core knows nothing about concrete modules — callers
+ * are responsible for passing all relevant packages at composition time.
+ */
+declare class PolicyCatalogFactory {
+  static build(packages: readonly PolicyPackage[]): PolicyCatalog;
+}
+//#endregion
+//#region src/core/policies/context/context-registry.instance.d.ts
+/**
+ * Official instance of the ContextResolverRegistry.
+ * Use `new ContextResolverRegistry()` plus `registerNamespacedContextResolversIn`
+ * when each runtime/composition root needs its own isolated resolver graph.
+ */
+declare const contextResolverRegistry: ContextResolverRegistry;
+declare function registerNamespacedContextResolvers(namespace: string, resolvers: readonly ContextValueResolver[]): Result<ContextResolverRegistry, string>;
+//#endregion
+//#region src/core/policies/context/path.d.ts
+declare class PolicyContextPath {
+  private static readonly FORBIDDEN_SEGMENTS;
+  private static resolve;
+  private static parseSegments;
+  private static isPlainRecord;
+  static getOrAbsent(obj: Record<string, unknown>, path: string): Result<unknown, "absent">;
+  static has(obj: Record<string, unknown>, path: string): boolean;
+  static set(obj: Record<string, unknown>, path: string, value: unknown): Result<void, string>;
+}
+//#endregion
+export { PolicyPackage as a, coreConfig as c, PolicyCatalogFactory as i, contextResolverRegistry as n, InMemoryPolicyDefinitionRepository as o, registerNamespacedContextResolvers as r, PolicyHashing as s, PolicyContextPath as t };
+//# sourceMappingURL=path.d.ts.map

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