@cullet/erp-core 1.0.10 → 1.1.0

package/KIT_CONTEXT.md

@@ -23,6 +23,73 @@ Núcleo arquitetural para sistemas ERP (e domínios transacionais com temporalid
 - **Policies permitem disable sem remover código**: `PolicyDefinition` aceita `enabled: false` e o repositório ignora definições desabilitadas.
 - **Composição isolada é de primeira classe**: use `new CoreConfig()`, `new ContextResolverRegistry()` e `registerNamespacedContextResolversIn(...)` quando precisar evitar singletons compartilhados.
 
+## [example] Exemplo end-to-end (Command + Repository + PolicyPort)
+
+Um `Command` carrega o agregado por um `ResultRepository`, consulta um
+`PolicyPort` (gate `ALLOW`/`DENY`) e persiste. Falhas recuperáveis voltam como
+`Result.err`, nunca como exceção.
+
+```ts
+class CancelOrder extends Command<
+    CancelOrderInput,
+    Result<Order, CancelOrderError>
+> {
+    constructor(
+        private readonly orders: ResultRepository<
+            Order,
+            string,
+            CancelOrderError
+        >,
+        private readonly policies: PolicyPort,
+    ) {
+        super();
+    }
+
+    protected async execute(input: CancelOrderInput) {
+        const found = await this.orders.findById(input.orderId);
+        if (found.isErr()) return found;
+        const order = found.getOrThrow();
+        if (!order)
+            return Result.err(
+                new NotFoundError("Order", { id: input.orderId }),
+            );
+
+        const evaluated = await this.policies.evaluate({
+            decisionId: asPolicyDecisionId(input.orderId),
+            policyKey: "order.cancel",
+            scopeChain: [],
+            contextVersion: 1,
+            seed: {
+                tenantId: asTenantId(input.tenantId),
+                schoolId: asSchoolId(input.schoolId),
+                fields: { orderStatus: order.status },
+            },
+        });
+        if (evaluated.isErr()) return evaluated;
+
+        const result = evaluated.getOrThrow();
+        if (result.kind === "GATE" && result.decision.status === "DENY") {
+            return Result.err(
+                AuthorizationError.policyDenied({
+                    action: "order.cancel",
+                    policyId: result.ref.definitionId,
+                    policyVersion: Number(result.ref.policyVersion),
+                    evaluatedAtIso: result.evaluatedAt.toISOString(),
+                }),
+            );
+        }
+
+        const saved = await this.orders.save({ ...order, status: "CANCELLED" });
+        if (saved.isErr()) return saved;
+        return Result.ok({ ...order, status: "CANCELLED" });
+    }
+}
+```
+
+- **Imports**: tudo do root `@cullet/erp-core`.
+- **`Repository` vs `ResultRepository`**: `Repository` (`save`/`delete` → `Promise<void>`) é o estilo imperativo; `ResultRepository` devolve `Result` para sinalizar not-found / concorrência otimista sem quebrar o fluxo.
+- **Referência compilada/testada**: `src/examples/application/cancel-order.example.ts` (+ `.spec.ts`).
+
 ## [extension-points] Pontos de extensão
 
 Implemente as portas em `application/ports/` para conectar a stack real:

package/README.md

@@ -13,7 +13,7 @@ Para o sumário prompt-friendly veja [`KIT_CONTEXT.md`](./KIT_CONTEXT.md). Para
 - **Erros de aplicação** — `AppError` discriminada por `code`: `ValidationError`, `NotFoundError`, `ConflictError`, `AuthorizationError`, `IntegrationError`.
 - **Result** — `Result<T, E>` e `Outcome` para retorno tipado da aplicação.
 - **Policies** — `PolicyCatalog`, `PolicyDefinition`, `PolicyResolver`, `PolicyService` e tipos associados para avaliação declarativa.
-- **Application** — portas de observabilidade (`LoggerPort`, `MetricsPort`, `TracerPort`) e `mapPolicyEvaluationError` para integrar a camada de aplicação.
+- **Application** — `UseCase`/`Command` (CQS, entrada `CommandInput` com `RequestedBy`), portas de persistência (`Repository` e a variante `ResultRepository`), `PolicyPort`, portas de observabilidade (`LoggerPort`, `MetricsPort`, `TracerPort`) e `mapPolicyEvaluationError`. Veja o [exemplo end-to-end](#exemplo-end-to-end).
 - **Exemplos** — rulesets de referência em `examples/rulesets/`, fora da superfície principal de domínio.
 
 ## Como começa
@@ -46,6 +46,133 @@ npx cullet fc erp-core@1.0.0
 
 O argumento do `fc` é o nome do kit no registry (`erp-core`), não o nome npm com escopo. O comando instala `@cullet/erp-core`, copia o `src/` para `./cullet/erp-core@1.0.0/` e registra o alias `@cullet/erp-core` no `tsconfig.json`.
 
+## Exemplo end-to-end
+
+Um `Command` concreto que orquestra um `ResultRepository` e um `PolicyPort`.
+O fluxo carrega o agregado, consulta uma policy declarativa (gate `ALLOW`/`DENY`)
+e só então persiste — toda falha recuperável (erro de infra no repositório,
+policy negando, agregado inexistente, conflito de concorrência otimista no
+`save`) volta como `Result.err(...)`, nunca como exceção atravessando a
+fronteira. O código abaixo é a versão consumidora do exemplo testado em
+[`src/examples/application/cancel-order.example.ts`](./src/examples/application/cancel-order.example.ts).
+
+```ts
+import {
+    AuthorizationError,
+    Command,
+    NotFoundError,
+    RequestedBy,
+    Result,
+    asPolicyDecisionId,
+    asSchoolId,
+    asTenantId,
+    type CommandInput,
+    type PolicyPort,
+    type ResultRepository,
+} from "@cullet/erp-core";
+
+type OrderStatus = "OPEN" | "CANCELLED";
+interface Order {
+    readonly id: string;
+    readonly status: OrderStatus;
+}
+
+// `CommandInput` obriga toda mutação a registrar quem a disparou.
+interface CancelOrderInput extends CommandInput {
+    readonly orderId: string;
+    readonly tenantId: string;
+    readonly schoolId: string;
+}
+
+type CancelOrderError = NotFoundError | AuthorizationError;
+
+class CancelOrder extends Command<
+    CancelOrderInput,
+    Result<Order, CancelOrderError>
+> {
+    constructor(
+        private readonly orders: ResultRepository<
+            Order,
+            string,
+            CancelOrderError
+        >,
+        private readonly policies: PolicyPort,
+    ) {
+        super();
+    }
+
+    protected async execute(
+        input: CancelOrderInput,
+    ): Promise<Result<Order, CancelOrderError>> {
+        // 1. Carrega o agregado; falhas de infra ficam in-band no Result.
+        const found = await this.orders.findById(input.orderId);
+        if (found.isErr()) return found;
+
+        const order = found.getOrThrow();
+        if (!order) {
+            return Result.err(
+                new NotFoundError("Order", { id: input.orderId }),
+            );
+        }
+
+        // 2. Decide via policy declarativa (um GATE retorna ALLOW/DENY).
+        const evaluated = await this.policies.evaluate({
+            decisionId: asPolicyDecisionId(input.orderId),
+            policyKey: "order.cancel",
+            scopeChain: [],
+            contextVersion: 1,
+            seed: {
+                tenantId: asTenantId(input.tenantId),
+                schoolId: asSchoolId(input.schoolId),
+                fields: { orderStatus: order.status },
+            },
+        });
+        if (evaluated.isErr()) return evaluated;
+
+        const result = evaluated.getOrThrow();
+        if (result.kind === "GATE" && result.decision.status === "DENY") {
+            return Result.err(
+                AuthorizationError.policyDenied({
+                    action: "order.cancel",
+                    resource: { type: "Order", id: order.id },
+                    policyId: result.ref.definitionId,
+                    policyVersion: Number(result.ref.policyVersion),
+                    evaluatedAtIso: result.evaluatedAt.toISOString(),
+                }),
+            );
+        }
+
+        // 3. Muta e persiste; um conflito de versão no save também volta como
+        //    Result.err — nunca uma exceção atravessando a fronteira.
+        const cancelled: Order = { ...order, status: "CANCELLED" };
+        const saved = await this.orders.save(cancelled);
+        if (saved.isErr()) return saved;
+
+        return Result.ok(cancelled);
+    }
+}
+
+// Chamada — `run` recebe a entrada e devolve o Result tipado.
+const result = await new CancelOrder(orderRepository, policyPort).run({
+    orderId: "order-42",
+    tenantId: "tenant-1",
+    schoolId: "school-1",
+    requestedBy: RequestedBy.fromUser("550e8400-e29b-41d4-a716-446655440000"),
+});
+
+result.match({
+    ok: (order) => console.log("cancelado", order.id),
+    err: (error) => console.error(error.code, error.message),
+});
+```
+
+`Repository<TEntity, TId>` (estilo imperativo, `save`/`delete` retornam
+`Promise<void>`) continua disponível quando você prefere lançar exceções;
+`ResultRepository` é a variante alinhada à filosofia "erros como valor" e
+permite sinalizar not-found / concorrência otimista sem quebrar o fluxo. Uma
+implementação in-memory de referência está em
+[`src/examples/application/in-memory-account-repository.example.ts`](./src/examples/application/in-memory-account-repository.example.ts).
+
 ## Composicao sem singletons
 
 Para isolamento por tenant, request ou teste, prefira instancias locais em vez

package/dist/app-error.d.ts

@@ -0,0 +1,108 @@
+//#region src/core/errors/types.d.ts
+type ErrorSeverity = "low" | "medium" | "high" | "critical";
+type JsonSafePrimitive = string | number | boolean | null;
+type JsonSafeValue = JsonSafePrimitive | JsonSafeValue[] | {
+  [key: string]: JsonSafeValue;
+};
+type JsonSafeRecord = Record<string, JsonSafeValue>;
+/**
+ * Options accepted by the AppError constructor.
+ * Subclasses can extend or pick from this type.
+ */
+type AppErrorOptions = {
+  /** Original error or exception that caused this error. */
+  cause?: unknown;
+  /** Arbitrary key-value metadata (will be sanitized to JSON-safe values). */
+  metadata?: Record<string, unknown>;
+  /** Error category/type for grouping (e.g., "authentication", "validation"). */
+  type?: string;
+  /** severity level for alerting/logging prioritization. */
+  severity?: ErrorSeverity;
+  /**
+   * Identifies a single execution "story" in the system. All operations
+   * related to the same logical flow must share the same correlationId.
+   */
+  correlationId?: string;
+  /**
+   * Identifies a specific technical request attempt (each retry may produce
+   * a new requestId), even when the correlationId stays the same.
+   */
+  requestId?: string;
+  /**
+   * Identifies a unique business intent (idempotency key); stays the same
+   * across technical retries and multiple requests that represent the same intent.
+   */
+  commandId?: string;
+  /** ISO timestamp of when the error was created (defaults to now). */
+  createdAtIso?: string;
+  /** Safe message that can be exposed to end users (no internal details). */
+  publicMessage?: string;
+};
+//#endregion
+//#region src/core/errors/app-error.d.ts
+/**
+ * Root of the application/domain error hierarchy. Every error the system raises
+ * on purpose extends `AppError`, which gives callers a single `instanceof` to
+ * catch and a uniform, serializable shape to log and transport.
+ *
+ * Beyond the native `Error` message it carries a stable `code` (the contract the
+ * outside world matches on), an optional non-leaking `publicMessage`, a
+ * severity, JSON-safe `metadata`, and the correlation/request/command ids that
+ * stitch an error back to the request that produced it. The metadata is
+ * validated as JSON-safe on construction, so a logger can serialize any
+ * `AppError` without hitting a circular reference or a non-serializable value.
+ *
+ * Abstract on purpose: callers should throw a specific subclass (e.g.
+ * {@link ValidationError}, {@link NotFoundError}) so the `code` and shape are
+ * meaningful, never a bare `AppError`.
+ */
+declare abstract class AppError extends Error {
+  readonly code: string;
+  readonly cause?: unknown;
+  readonly metadata?: JsonSafeRecord;
+  readonly type?: string;
+  readonly severity?: ErrorSeverity;
+  readonly createdAtIso: string;
+  readonly publicMessage?: string;
+  /**
+   * Identifies a single execution "story" in the system. All operations
+   * related to the same logical flow must share the same correlationId.
+   */
+  readonly correlationId?: string;
+  /**
+   * Identifies a specific technical request attempt (each retry may produce
+   * a new requestId), even when the correlationId stays the same.
+   */
+  readonly requestId?: string;
+  /**
+   * Marks the business intent / idempotency key; stays the same across
+   * technical retries and multiple requests that represent the same intent.
+   */
+  readonly commandId?: string;
+  /**
+   * Builds the common error envelope shared by every subclass.
+   *
+   * `name` is taken from `new.target` so the thrown instance reports its
+   * concrete subclass name (not `"AppError"`), and the prototype is re-pinned
+   * via `setPrototypeOf` so `instanceof` keeps working after transpilation to
+   * older targets where extending built-ins breaks the chain. `createdAtIso`
+   * defaults to now, and `metadata` is validated as JSON-safe so the error is
+   * always serializable.
+   *
+   * Declared `protected`: instantiate a concrete subclass, never `AppError`.
+   *
+   * @param message - The internal, developer-facing message.
+   * @param code - The stable machine-readable code callers match on.
+   * @param options - Optional cause, metadata, severity, and correlation ids.
+   * @throws When `options.metadata` contains a value that is not JSON-safe.
+   */
+  protected constructor(message: string, code: string, options?: AppErrorOptions);
+  /**
+   * Returns a JSON-safe representation of the error.
+   * Does NOT include `cause` by default (to avoid leaking internal details).
+   */
+  toJSON(): Record<string, unknown>;
+}
+//#endregion
+export { JsonSafeRecord as a, JsonSafePrimitive as i, AppErrorOptions as n, JsonSafeValue as o, ErrorSeverity as r, AppError as t };
+//# sourceMappingURL=app-error.d.ts.map

package/dist/application/index.d.ts

@@ -0,0 +1,2 @@
+import { A as TracerPort, C as RequestedBy, D as UseCaseObservability, E as UseCase, M as MetricsPort, N as LogPayload, O as TraceAttributeValue, P as LoggerPort, S as CommandInput, T as MaybePromise, _ as PolicyEvaluationInput, a as TemporalContext, b as PolicyPortError, c as CacheStrategy, d as mapPolicyEvaluationError, f as TemporalHistory, g as ResultRepository, h as Repository, i as CreateTemporalContextInput, j as MetricLabels, k as TraceSpan, l as Page, n as TemporalUseCaseInput, o as assertTemporalContext, p as TemporalRepository, r as TemporalizedContextSeed, s as createTemporalContext, t as TemporalUseCase, u as Query, v as PolicyEvaluationOutput, w as RequestedByKind, x as Command, y as PolicyPort } from "../temporal-use-case.js";
+export { CacheStrategy, Command, CommandInput, CreateTemporalContextInput, LogPayload, LoggerPort, MaybePromise, MetricLabels, MetricsPort, Page, PolicyEvaluationInput, PolicyEvaluationOutput, PolicyPort, PolicyPortError, Query, Repository, RequestedBy, RequestedByKind, ResultRepository, TemporalContext, TemporalHistory, TemporalRepository, TemporalUseCase, TemporalUseCaseInput, TemporalizedContextSeed, TraceAttributeValue, TraceSpan, TracerPort, UseCase, UseCaseObservability, assertTemporalContext, createTemporalContext, mapPolicyEvaluationError };

package/dist/application/index.js

@@ -0,0 +1,2 @@
+import { a as Query, c as RequestedBy, l as UseCase, n as assertTemporalContext, o as mapPolicyEvaluationError, r as createTemporalContext, s as Command, t as TemporalUseCase } from "../temporal-use-case.js";
+export { Command, Query, RequestedBy, TemporalUseCase, UseCase, assertTemporalContext, createTemporalContext, mapPolicyEvaluationError };

package/dist/errors/index.d.ts

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

package/dist/errors/index.js

@@ -1,3 +1,5 @@
-import { a as stableStringify, c as ErrorCodes, i as sha256Hex, l as serializationErrorCode, n as UnexpectedError, o as AppError, r as payloadHash, s as assertJsonSafeMetadata } from "../validation-code.js";
-import { C as UniqueConstraintViolationError, D as AuthenticationError, E as AuthorizationError, S as DuplicateError, T as BusinessRuleViolationError, _ as IdempotencyKeyMissingError, a as evaluateTemporalWindow, b as AlreadyExistsError, c as SerializationInError, d as safePreview, f as NotFoundError, g as IdempotencyInProgressError, h as IdempotencyError, i as TemporalError, l as SerializationMessages, m as IntegrationError, n as ExpiredError, o as SerializationCodes, p as LegacyIncompatibleError, r as NotYetValidError, s as SerializationError, t as ValidationError, u as SerializationOutError, v as IdempotencyPayloadMismatchError, w as translateUniqueViolationToDuplicate, x as ConflictError, y as IdempotencyReplayNotSupportedError } from "../validation-error.js";
+import { a as ErrorCodes, i as assertJsonSafeMetadata, n as UnexpectedError, o as serializationErrorCode, r as AppError } from "../validation-code.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";
 export { AlreadyExistsError, AppError, AuthenticationError, AuthorizationError, BusinessRuleViolationError, ConflictError, SerializationInError as DeserializationError, SerializationInError, DuplicateError, ErrorCodes, ExpiredError, IdempotencyError, IdempotencyInProgressError, IdempotencyKeyMissingError, IdempotencyPayloadMismatchError, IdempotencyReplayNotSupportedError, IntegrationError, LegacyIncompatibleError, NotFoundError, NotYetValidError, SerializationCodes, SerializationError, SerializationMessages, SerializationOutError, TemporalError, UnexpectedError, UniqueConstraintViolationError, ValidationError, assertJsonSafeMetadata, evaluateTemporalWindow, payloadHash, safePreview, serializationErrorCode, sha256Hex, stableStringify, translateUniqueViolationToDuplicate };

package/dist/gate-engine-registry.d.ts

@@ -0,0 +1,80 @@
+import { I as Result, c as PolicyViolation, g as CoreConfig, h as Outcome, l as VersionedGateEngine, p as ConditionNode, s as PolicyContext, t as GateOutcome } from "./gate-types.js";
+import { z } from "zod";
+
+//#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-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
+export { ComputeOutcome as a, VersionedComputeEngine as c, ComputeDecisionTableRule as d, ComputeParamsPayload as f, ComputeEvaluatorRegistration as i, ComputePayload as l, ComputeRegistry as n, ComputeOutcomeData as o, ComputePayloadV1 as p, ComputeEvaluator as r, ComputeStatus as s, GateEngineRegistry as t, ComputeDecisionTablePayload as u };
+//# sourceMappingURL=gate-engine-registry.d.ts.map

package/dist/gate-v1-payload.schema.js

@@ -1,31 +1,5 @@
+import { r as isValidDate } from "./temporal-guards.js";
 import { z } from "zod";
-//#region src/core/exceptions/domain-exception.ts
-var DomainException = class extends Error {
-	constructor(message) {
-		super(message);
-		Object.setPrototypeOf(this, new.target.prototype);
-		this.name = new.target.name;
-	}
-};
-//#endregion
-//#region src/core/exceptions/invariant-violation-exception.ts
-var InvariantViolationException = class extends DomainException {
-	constructor(message) {
-		super(message);
-	}
-};
-//#endregion
-//#region src/core/shared/temporal-guards.ts
-function isValidDate(value) {
-	return value instanceof Date && !Number.isNaN(value.getTime());
-}
-function cloneDate(date) {
-	return new Date(date.getTime());
-}
-function assertValidDate(fieldName, value) {
-	if (!isValidDate(value)) throw new InvariantViolationException(`${fieldName} must be a valid Date instance`);
-}
-//#endregion
 //#region src/core/config/silent-policy-reporter.ts
 var SilentPolicyReporter = class {
 	report(_event) {}
@@ -720,6 +694,6 @@ var GatePayloadSchemaV1 = class GatePayloadSchemaV1 {
 };
 const gatePayloadSchema = GatePayloadSchemaV1.schema;
 //#endregion
-export { DomainException as _, conditionNodeSchema as a, Ok as c, CoreConfig as d, SilentPolicyReporter as f, InvariantViolationException as g, isValidDate as h, conditionLeafNodeSchema as i, Result as l, cloneDate as m, gatePayloadSchema as n, PolicyContextPath as o, assertValidDate as p, ConditionEvaluatorV1 as r, Err as s, GatePayloadSchemaV1 as t, coreConfig as u };
+export { conditionNodeSchema as a, Ok as c, CoreConfig as d, SilentPolicyReporter as f, conditionLeafNodeSchema as i, Result as l, gatePayloadSchema as n, PolicyContextPath as o, ConditionEvaluatorV1 as r, Err as s, GatePayloadSchemaV1 as t, coreConfig as u };
 
 //# sourceMappingURL=gate-v1-payload.schema.js.map