@cullet/erp-core 1.0.11 → 1.2.0

package/KIT_CONTEXT.md

@@ -22,6 +22,7 @@ Núcleo arquitetural para sistemas ERP (e domínios transacionais com temporalid
 - **Policies como dados**, não como if-statements: avaliáveis, compostas, serializáveis.
 - **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.
+- **`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. Exemplo end-to-end (Command + ResultRepository + PolicyPort) compilado e testado em `src/examples/application/cancel-order.example.ts` (+ `.spec.ts`).
 
 ## [extension-points] Pontos de extensão
 

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 MetricLabels, C as RequestedByKind, D as TraceAttributeValue, E as UseCaseObservability, M as LogPayload, N as LoggerPort, O as TraceSpan, S as RequestedBy, T as UseCase, _ as PolicyEvaluationOutput, a as TemporalContext, b as Command, c as CacheStrategy, d as mapPolicyEvaluationError, f as TemporalHistory, g as PolicyEvaluationInput, h as ResultRepository, i as CreateTemporalContextInput, j as MetricsPort, k as TracerPort, l as Page, m as Repository, n as TemporalUseCaseInput, o as assertTemporalContext, p as TemporalRepository, r as TemporalizedContextSeed, s as createTemporalContext, t as TemporalUseCase, u as Query, v as PolicyPort, w as MaybePromise, x as CommandInput, y as PolicyPortError } 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,3 @@
+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";
+export { Command, Query, RequestedBy, TemporalUseCase, UseCase, assertTemporalContext, createTemporalContext, mapPolicyEvaluationError };

package/dist/domain/index.d.ts

@@ -0,0 +1,3 @@
+import { t as DeepReadonly } from "../immutable.js";
+import { a as EntityState, i as Entity, n as ValueObject, r as ValueObjectPluginContract, t as UuidIdentifier } from "../uuid-identifier.js";
+export { type DeepReadonly, Entity, type EntityState, UuidIdentifier, ValueObject, type ValueObjectPluginContract };

package/dist/domain/index.js

@@ -0,0 +1,3 @@
+import { n as Entity, t as ValueObject } from "../value-object.js";
+import { t as UuidIdentifier } from "../uuid-identifier.js";
+export { Entity, UuidIdentifier, ValueObject };

package/dist/domain-event-contracts.d.ts

@@ -0,0 +1,27 @@
+import { n as ContractVersion } from "./version.js";
+
+//#region src/core/versioning/domain-event-contracts.d.ts
+interface DomainEventContractSelection {
+  readonly entity?: boolean;
+  readonly valueObject?: boolean;
+  readonly useCase?: boolean;
+}
+interface DomainEventContractVersions {
+  readonly entity_contract?: ContractVersion;
+  readonly value_object_contract?: ContractVersion;
+  readonly use_case_contract?: ContractVersion;
+}
+interface CreateDomainEventEnvelopeInput<TPayload> {
+  readonly aggregateVersion: number;
+  readonly payload: TPayload;
+  readonly contracts: DomainEventContractSelection;
+}
+interface DomainEventEnvelope<TPayload> extends DomainEventContractVersions {
+  readonly aggregate_version: number;
+  readonly payload: TPayload;
+}
+declare function buildDomainEventContractVersions(selection: DomainEventContractSelection): DomainEventContractVersions;
+declare function createDomainEventEnvelope<TPayload>(input: CreateDomainEventEnvelopeInput<TPayload>): DomainEventEnvelope<TPayload>;
+//#endregion
+export { buildDomainEventContractVersions as a, DomainEventEnvelope as i, DomainEventContractSelection as n, createDomainEventEnvelope as o, DomainEventContractVersions as r, CreateDomainEventEnvelopeInput as t };
+//# sourceMappingURL=domain-event-contracts.d.ts.map

package/dist/domain-event-contracts.js

@@ -0,0 +1,22 @@
+import { t as UseCase } from "./use-case.js";
+import { n as Entity, r as assertValidAggregateVersion, t as ValueObject } from "./value-object.js";
+//#region src/core/versioning/domain-event-contracts.ts
+function buildDomainEventContractVersions(selection) {
+	const contractVersions = {};
+	if (selection.entity) contractVersions.entity_contract = Entity.CONTRACT_VERSION;
+	if (selection.valueObject) contractVersions.value_object_contract = ValueObject.CONTRACT_VERSION;
+	if (selection.useCase) contractVersions.use_case_contract = UseCase.CONTRACT_VERSION;
+	return Object.freeze(contractVersions);
+}
+function createDomainEventEnvelope(input) {
+	assertValidAggregateVersion(input.aggregateVersion);
+	return Object.freeze({
+		aggregate_version: input.aggregateVersion,
+		payload: input.payload,
+		...buildDomainEventContractVersions(input.contracts)
+	});
+}
+//#endregion
+export { createDomainEventEnvelope as n, buildDomainEventContractVersions as t };
+
+//# sourceMappingURL=domain-event-contracts.js.map

package/dist/domain-event-contracts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-event-contracts.js","names":[],"sources":["../src/core/versioning/domain-event-contracts.ts"],"sourcesContent":["import { UseCase } from \"../application/use-case.js\";\nimport { Entity } from \"../domain/entity.js\";\nimport { ValueObject } from \"../domain/value-object.js\";\nimport { assertValidAggregateVersion } from \"../shared/aggregate-version.js\";\nimport { type ContractVersion } from \"./version.js\";\n\ninterface DomainEventContractSelection {\n    readonly entity?: boolean;\n    readonly valueObject?: boolean;\n    readonly useCase?: boolean;\n}\n\ninterface DomainEventContractVersions {\n    readonly entity_contract?: ContractVersion;\n    readonly value_object_contract?: ContractVersion;\n    readonly use_case_contract?: ContractVersion;\n}\n\ninterface CreateDomainEventEnvelopeInput<TPayload> {\n    readonly aggregateVersion: number;\n    readonly payload: TPayload;\n    readonly contracts: DomainEventContractSelection;\n}\n\ninterface DomainEventEnvelope<TPayload> extends DomainEventContractVersions {\n    readonly aggregate_version: number;\n    readonly payload: TPayload;\n}\n\nfunction buildDomainEventContractVersions(\n    selection: DomainEventContractSelection,\n): DomainEventContractVersions {\n    const contractVersions: {\n        entity_contract?: ContractVersion;\n        value_object_contract?: ContractVersion;\n        use_case_contract?: ContractVersion;\n    } = {};\n\n    if (selection.entity) {\n        contractVersions.entity_contract = Entity.CONTRACT_VERSION;\n    }\n\n    if (selection.valueObject) {\n        contractVersions.value_object_contract = ValueObject.CONTRACT_VERSION;\n    }\n\n    if (selection.useCase) {\n        contractVersions.use_case_contract = UseCase.CONTRACT_VERSION;\n    }\n\n    return Object.freeze(contractVersions);\n}\n\nfunction createDomainEventEnvelope<TPayload>(\n    input: CreateDomainEventEnvelopeInput<TPayload>,\n): DomainEventEnvelope<TPayload> {\n    assertValidAggregateVersion(input.aggregateVersion);\n\n    return Object.freeze({\n        aggregate_version: input.aggregateVersion,\n        payload: input.payload,\n        ...buildDomainEventContractVersions(input.contracts),\n    });\n}\n\nexport {\n    buildDomainEventContractVersions,\n    createDomainEventEnvelope,\n    type CreateDomainEventEnvelopeInput,\n    type DomainEventContractSelection,\n    type DomainEventContractVersions,\n    type DomainEventEnvelope,\n};\n"],"mappings":";;;AA6BA,SAAS,iCACL,WAC2B;CAC3B,MAAM,mBAIF,CAAC;CAEL,IAAI,UAAU,QACV,iBAAiB,kBAAkB,OAAO;CAG9C,IAAI,UAAU,aACV,iBAAiB,wBAAwB,YAAY;CAGzD,IAAI,UAAU,SACV,iBAAiB,oBAAoB,QAAQ;CAGjD,OAAO,OAAO,OAAO,gBAAgB;AACzC;AAEA,SAAS,0BACL,OAC6B;CAC7B,4BAA4B,MAAM,gBAAgB;CAElD,OAAO,OAAO,OAAO;EACjB,mBAAmB,MAAM;EACzB,SAAS,MAAM;EACf,GAAG,iCAAiC,MAAM,SAAS;CACvD,CAAC;AACL"}

package/dist/domain-exception.d.ts

@@ -0,0 +1,7 @@
+//#region src/core/exceptions/domain-exception.d.ts
+declare abstract class DomainException extends Error {
+  constructor(message: string);
+}
+//#endregion
+export { DomainException as t };
+//# sourceMappingURL=domain-exception.d.ts.map

package/dist/domain-exception.js

@@ -0,0 +1,12 @@
+//#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
+export { DomainException as t };
+
+//# sourceMappingURL=domain-exception.js.map

package/dist/domain-exception.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-exception.js","names":[],"sources":["../src/core/exceptions/domain-exception.ts"],"sourcesContent":["abstract class DomainException extends Error {\n    constructor(message: string) {\n        super(message);\n        Object.setPrototypeOf(this, new.target.prototype);\n        this.name = new.target.name;\n    }\n}\n\nexport { DomainException };\n"],"mappings":";AAAA,IAAe,kBAAf,cAAuC,MAAM;CACzC,YAAY,SAAiB;EACzB,MAAM,OAAO;EACb,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;EAChD,KAAK,OAAO,IAAI,OAAO;CAC3B;AACJ"}

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 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";
 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/exceptions/index.d.ts

@@ -0,0 +1,5 @@
+import { t as ValidationCode } from "../validation-code.js";
+import { t as ValidationField } from "../validation-field.js";
+import { t as DomainException } from "../domain-exception.js";
+import { a as InvariantViolationException, c as BusinessRuleViolationException, i as ValidationViolation, n as MultipleValidationException, o as InvalidStateTransitionException, r as ValidationException, s as EntityNotFoundException, t as InvalidValueException } from "../validation-exception.js";
+export { BusinessRuleViolationException, DomainException, EntityNotFoundException, InvalidStateTransitionException, InvalidValueException, InvariantViolationException, MultipleValidationException, ValidationCode, ValidationException, ValidationField, ValidationViolation };

package/dist/exceptions/index.js

@@ -0,0 +1,7 @@
+import { t as ValidationCode } from "../validation-code.js";
+import { t as ValidationField } from "../validation-field.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";
+export { BusinessRuleViolationException, DomainException, EntityNotFoundException, InvalidStateTransitionException, InvalidValueException, InvariantViolationException, MultipleValidationException, ValidationCode, ValidationException, ValidationField };

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

@@ -0,0 +1,81 @@
+import { a as Result, n as Outcome } from "./outcome.js";
+import { c as PolicyViolation, l as VersionedGateEngine, m as CoreConfig, 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-engine-registry.js

@@ -1,4 +1,5 @@
-import { a as conditionNodeSchema, l as Result, r as ConditionEvaluatorV1, t as GatePayloadSchemaV1, u as coreConfig } from "./gate-v1-payload.schema.js";
+import { a as conditionNodeSchema, r as ConditionEvaluatorV1, s as coreConfig, t as GatePayloadSchemaV1 } from "./gate-v1-payload.schema.js";
+import { r as Result } from "./result.js";
 import { z } from "zod";
 //#region src/core/policies/engines/v1/compute/compute-payload.schema.ts
 const computeDecisionTableRuleSchema = z.object({

package/dist/gate-engine-registry.js.map

@@ -1 +1 @@
-{"version":3,"file":"gate-engine-registry.js","names":[],"sources":["../src/core/policies/engines/v1/compute/compute-payload.schema.ts","../src/core/policies/engines/parse-compute-payload.ts","../src/core/policies/engines/compute-engine-registry.ts","../src/core/policies/engines/compute-evaluator-registry.ts","../src/core/policies/engines/v1/compute/resolve-decision-table-v1.ts","../src/core/policies/engines/v1/compute/compute-engine-v1.ts","../src/core/policies/engines/compute-registry.ts","../src/core/policies/engines/parse-gate-payload.ts","../src/core/policies/engines/gate-engine-registry.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { Result } from \"../../../../result/result.js\";\n\nimport { conditionNodeSchema } from \"../condition-schema.js\";\nimport type { ConditionNode } from \"../condition-types.js\";\n\n// ─── Pattern 1: Params ──────────────────────────────────────────────────────\n\nexport interface ComputeParamsPayload {\n    readonly type: \"params\";\n    readonly data: Readonly<Record<string, unknown>>;\n}\n\n// ─── Pattern 2: Decision table ──────────────────────────────────────────────\n\nexport interface ComputeDecisionTableRule<R = unknown> {\n    readonly conditions: ConditionNode;\n    readonly result: R;\n}\n\nexport interface ComputeDecisionTablePayload<R = unknown> {\n    readonly type: \"decision-table\";\n    readonly rules: readonly ComputeDecisionTableRule<R>[];\n    readonly default: R;\n}\n\n// ─── Union ──────────────────────────────────────────────────────────────────\n\nexport type ComputePayloadV1 =\n    | ComputeDecisionTablePayload<unknown>\n    | ComputeParamsPayload;\n\n// ─── Zod schemas ────────────────────────────────────────────────────────────\n\nconst computeDecisionTableRuleSchema = z.object({\n    conditions: conditionNodeSchema,\n    result: z.unknown(),\n});\n\nexport class ComputePayloadSchemaV1 {\n    static readonly schema = z.union([\n        z\n            .object({\n                type: z.literal(\"decision-table\"),\n                rules: z.array(computeDecisionTableRuleSchema).min(1),\n                default: z.unknown(),\n            })\n            .strict(),\n        z\n            .object({\n                type: z.literal(\"params\"),\n                data: z.record(z.string(), z.unknown()),\n            })\n            .strict(),\n    ]);\n\n    static parse(payload: unknown): Result<ComputePayloadV1, string> {\n        const parsed = ComputePayloadSchemaV1.schema.safeParse(payload);\n        if (!parsed.success) {\n            const details = parsed.error.issues\n                .map((issue) => {\n                    const path = issue.path.join(\".\");\n                    return path.length > 0\n                        ? `${path}: ${issue.message}`\n                        : issue.message;\n                })\n                .join(\"; \");\n\n            return Result.err(`Invalid compute payload: ${details}`);\n        }\n\n        return Result.ok(parsed.data as ComputePayloadV1);\n    }\n}\n\nexport const computePayloadSchema = ComputePayloadSchemaV1.schema;\n","import type { Result as ResultType } from \"../../result/result.js\";\nimport { Result } from \"../../result/result.js\";\n\nimport type { ComputePayload } from \"./compute-payload.js\";\nimport { ComputePayloadSchemaV1 } from \"./v1/compute/compute-payload.schema.js\";\n\nexport type ComputePayloadParser = (\n    payload: unknown,\n) => ResultType<ComputePayload, string>;\n\nexport class ComputePayloadParserRegistry {\n    private readonly parsers = new Map<number, ComputePayloadParser>();\n\n    register(payloadSchemaVersion: number, parser: ComputePayloadParser): void {\n        this.parsers.set(payloadSchemaVersion, parser);\n    }\n\n    get(payloadSchemaVersion: number): ComputePayloadParser | undefined {\n        return this.parsers.get(payloadSchemaVersion);\n    }\n\n    parse(payloadSchemaVersion: number, payload: unknown) {\n        const parser = this.parsers.get(payloadSchemaVersion);\n\n        if (parser === undefined) {\n            return Result.err(\n                `No compute payload parser registered for schema version \"${payloadSchemaVersion}\"`,\n            );\n        }\n\n        return parser(payload);\n    }\n}\n\nexport class ComputePayloadParsers {\n    private static readonly registry = new ComputePayloadParserRegistry();\n    private static defaultsRegistered = false;\n\n    // Registers the built-in v1 parser lazily, the first time the default\n    // dispatcher is touched. Done here — rather than as a top-level module\n    // statement — so the package's `\"sideEffects\": false` flag stays honest and\n    // a tree-shaking bundler cannot drop the v1 registration and leave the\n    // compute engine unable to parse v1 payloads at runtime.\n    private static ensureDefaults(): void {\n        if (ComputePayloadParsers.defaultsRegistered) {\n            return;\n        }\n        ComputePayloadParsers.defaultsRegistered = true;\n        ComputePayloadParsers.registry.register(\n            1,\n            ComputePayloadSchemaV1.parse,\n        );\n    }\n\n    static register(\n        payloadSchemaVersion: number,\n        parser: ComputePayloadParser,\n    ): void {\n        ComputePayloadParsers.ensureDefaults();\n        ComputePayloadParsers.registry.register(payloadSchemaVersion, parser);\n    }\n\n    static get(payloadSchemaVersion: number): ComputePayloadParser | undefined {\n        ComputePayloadParsers.ensureDefaults();\n        return ComputePayloadParsers.registry.get(payloadSchemaVersion);\n    }\n\n    static parse(payloadSchemaVersion: number, payload: unknown) {\n        ComputePayloadParsers.ensureDefaults();\n        return ComputePayloadParsers.registry.parse(\n            payloadSchemaVersion,\n            payload,\n        );\n    }\n}\n\nexport type { ComputePayload };\n","import { Result } from \"../../result/result.js\";\n\nimport type { PolicyContext } from \"./gate-types.js\";\nimport { ComputePayloadParsers } from \"./parse-compute-payload.js\";\nimport type { ComputeEvaluatorRegistry } from \"./compute-evaluator-registry.js\";\nimport type {\n    ComputeOutcome,\n    VersionedComputeEngine,\n} from \"./compute-types.js\";\n\nexport class ComputeEngineRegistry {\n    private readonly engines = new Map<number, VersionedComputeEngine>();\n\n    register(engine: VersionedComputeEngine): void {\n        this.engines.set(engine.version, engine);\n    }\n\n    get(version: number): VersionedComputeEngine | undefined {\n        return this.engines.get(version);\n    }\n\n    evaluate(\n        version: number,\n        params: {\n            readonly policyKey: string;\n            readonly payloadSchemaVersion: number;\n            readonly payload: unknown;\n            readonly context: PolicyContext;\n            readonly evaluators: ComputeEvaluatorRegistry;\n        },\n    ): Result<ComputeOutcome, string> {\n        const engine = this.get(version);\n        if (engine === undefined) {\n            return Result.err(\n                `No compute engine registered for version \"${version}\"`,\n            );\n        }\n\n        const evaluator = params.evaluators.get(params.policyKey, version);\n        if (evaluator === undefined) {\n            return Result.err(\n                `No compute evaluator registered for policy key \"${params.policyKey}\" and version \"${version}\"`,\n            );\n        }\n\n        const parsedPayloadResult = ComputePayloadParsers.parse(\n            params.payloadSchemaVersion,\n            params.payload,\n        );\n        if (parsedPayloadResult.isErr()) {\n            return Result.err(parsedPayloadResult.errorOrNull()!);\n        }\n\n        return engine.evaluate(\n            parsedPayloadResult.getOrNull()!,\n            params.context,\n            evaluator,\n        );\n    }\n}\n","import type {\n    ComputeEvaluator,\n    ComputeEvaluatorRegistration,\n} from \"./compute-types.js\";\n\nexport class ComputeEvaluatorRegistry {\n    private readonly evaluators = new Map<string, ComputeEvaluator>();\n\n    private static toRegistryKey(policyKey: string, version: number): string {\n        return `${policyKey}::${version}`;\n    }\n\n    register(registration: ComputeEvaluatorRegistration): void {\n        this.evaluators.set(\n            ComputeEvaluatorRegistry.toRegistryKey(\n                registration.policyKey,\n                registration.version,\n            ),\n            registration.evaluator,\n        );\n    }\n\n    get(policyKey: string, version: number): ComputeEvaluator | undefined {\n        return this.evaluators.get(\n            ComputeEvaluatorRegistry.toRegistryKey(policyKey, version),\n        );\n    }\n}\n","import { Result } from \"../../../../result/result.js\";\n\nimport type { ConditionEvaluationOptions } from \"../../condition-evaluator-reporter.js\";\n\nimport { ConditionEvaluatorV1 } from \"../condition-evaluator.js\";\nimport type { ComputeDecisionTablePayload } from \"./compute-payload.schema.js\";\n\nconst COMPUTE_CONDITION_EVAL_FAILED_TAG = \"COMPUTE_CONDITION_EVAL_FAILED\";\n\nexport class DecisionTableResolverV1 {\n    constructor(\n        private readonly payload: ComputeDecisionTablePayload,\n        private readonly context: Record<string, unknown>,\n        private readonly conditionEvaluationOptions: ConditionEvaluationOptions,\n    ) {}\n\n    private wrapConditionEvaluationError(\n        error: string,\n    ): Result<unknown, string> {\n        return Result.err(`${COMPUTE_CONDITION_EVAL_FAILED_TAG}: ${error}`);\n    }\n\n    resolve(): Result<unknown, string> {\n        const evaluator = new ConditionEvaluatorV1(\n            this.context,\n            this.conditionEvaluationOptions,\n        );\n\n        for (const rule of this.payload.rules) {\n            const conditionResult = evaluator.evaluate(rule.conditions);\n            if (conditionResult.isErr()) {\n                return this.wrapConditionEvaluationError(\n                    conditionResult.errorOrNull()!,\n                );\n            }\n\n            if (conditionResult.getOrNull()) {\n                return Result.ok(rule.result);\n            }\n        }\n\n        return Result.ok(this.payload.default);\n    }\n\n    static resolve(\n        payload: ComputeDecisionTablePayload,\n        context: Record<string, unknown>,\n        conditionEvaluationOptions: ConditionEvaluationOptions,\n    ): Result<unknown, string> {\n        return new DecisionTableResolverV1(\n            payload,\n            context,\n            conditionEvaluationOptions,\n        ).resolve();\n    }\n}\n","import { type CoreConfig, coreConfig } from \"../../../../config/index.js\";\nimport { Result } from \"../../../../result/result.js\";\n\nimport type { ComputePayloadV1 as ComputePayload } from \"./compute-payload.schema.js\";\nimport { DecisionTableResolverV1 } from \"./resolve-decision-table-v1.js\";\nimport type {\n    ComputeEvaluator,\n    ComputeOutcome,\n    VersionedComputeEngine,\n} from \"../../compute-types.js\";\nimport type { PolicyContext } from \"../../gate-types.js\";\n\n// ─── Compute engine v1 ───────────────────────────────────────────────────────\n\nconst COMPUTE_ENGINE_VERSION = 1;\n\nexport class ComputeEngineV1 implements VersionedComputeEngine {\n    readonly version = COMPUTE_ENGINE_VERSION;\n    private readonly coreConfig: CoreConfig;\n\n    constructor(params: { readonly coreConfig?: CoreConfig } = {}) {\n        this.coreConfig = params.coreConfig ?? coreConfig;\n    }\n\n    /**\n     * Evaluates an already-parsed ComputePayload against a context.\n     * Pure function — no side effects.\n     *\n     * For `params`: forwards `payload.data` directly to the evaluator.\n     * For `decision-table`: evaluates the rules in order and passes the `result`\n     * of the first one that satisfies its conditions, or `default` if none match.\n     *\n     * The evaluator is responsible for validating and transforming the final value.\n     */\n    evaluate(\n        payload: ComputePayload,\n        context: PolicyContext,\n        evaluator: ComputeEvaluator,\n    ): Result<ComputeOutcome, string> {\n        if (payload.type === \"params\") {\n            return evaluator.evaluate(payload.data, context);\n        }\n\n        const resolvedResult = DecisionTableResolverV1.resolve(\n            payload,\n            context,\n            this.coreConfig.getConditionEvaluationOptions(\n                COMPUTE_ENGINE_VERSION,\n            ),\n        );\n        if (resolvedResult.isErr()) {\n            return Result.err(resolvedResult.errorOrNull()!);\n        }\n\n        return evaluator.evaluate(resolvedResult.getOrNull()!, context);\n    }\n}\n","import { type CoreConfig, coreConfig } from \"../../config/index.js\";\nimport type { Result } from \"../../result/result.js\";\n\nimport { ComputeEngineRegistry } from \"./compute-engine-registry.js\";\nimport { ComputeEvaluatorRegistry } from \"./compute-evaluator-registry.js\";\nimport type { PolicyContext } from \"./gate-types.js\";\nimport type {\n    ComputeEvaluator,\n    ComputeEvaluatorRegistration,\n    ComputeOutcome,\n    VersionedComputeEngine,\n} from \"./compute-types.js\";\nimport { ComputeEngineV1 } from \"./v1/compute/index.js\";\n\nexport interface ComputeRegistryOptions {\n    readonly coreConfig?: CoreConfig;\n}\n\nexport class ComputeRegistry {\n    private readonly engines = new ComputeEngineRegistry();\n    private readonly evaluators = new ComputeEvaluatorRegistry();\n\n    constructor(params: ComputeRegistryOptions = {}) {\n        const resolvedCoreConfig = params.coreConfig ?? coreConfig;\n\n        this.engines.register(\n            new ComputeEngineV1({\n                coreConfig: resolvedCoreConfig,\n            }),\n        );\n    }\n\n    register(registration: ComputeEvaluatorRegistration): void {\n        this.evaluators.register(registration);\n    }\n\n    registerEngine(engine: VersionedComputeEngine): void {\n        this.engines.register(engine);\n    }\n\n    getEngine(version: number): VersionedComputeEngine | undefined {\n        return this.engines.get(version);\n    }\n\n    getEvaluator(\n        policyKey: string,\n        version: number,\n    ): ComputeEvaluator | undefined {\n        return this.evaluators.get(policyKey, version);\n    }\n\n    evaluate(\n        policyKey: string,\n        computeEngineVersion: number,\n        payloadSchemaVersion: number,\n        payload: unknown,\n        context: PolicyContext,\n    ): Result<ComputeOutcome, string> {\n        return this.engines.evaluate(computeEngineVersion, {\n            policyKey,\n            payloadSchemaVersion,\n            payload,\n            context,\n            evaluators: this.evaluators,\n        });\n    }\n}\n","import type { Result as ResultType } from \"../../result/result.js\";\nimport { Result } from \"../../result/result.js\";\n\nimport type { GatePayload } from \"./gate-payload.js\";\nimport { GatePayloadSchemaV1 } from \"./v1/gate/gate-v1-payload.schema.js\";\n\nexport type GatePayloadParser = (\n    payload: unknown,\n) => ResultType<GatePayload, string>;\n\nexport class GatePayloadParserRegistry {\n    private readonly parsers = new Map<number, GatePayloadParser>();\n\n    register(engineVersion: number, parser: GatePayloadParser): void {\n        this.parsers.set(engineVersion, parser);\n    }\n\n    get(engineVersion: number): GatePayloadParser | undefined {\n        return this.parsers.get(engineVersion);\n    }\n\n    parse(engineVersion: number, payload: unknown) {\n        const parser = this.parsers.get(engineVersion);\n\n        if (parser === undefined) {\n            return Result.err(\n                `No gate payload parser registered for engine version \"${engineVersion}\"`,\n            );\n        }\n\n        return parser(payload);\n    }\n}\n\nexport class GatePayloadParsers {\n    private static readonly registry = new GatePayloadParserRegistry();\n    private static defaultsRegistered = false;\n\n    // Registers the built-in v1 parser lazily, the first time the default\n    // dispatcher is touched. Done here — rather than as a top-level module\n    // statement — so the package's `\"sideEffects\": false` flag stays honest and\n    // a tree-shaking bundler cannot drop the v1 registration and leave the gate\n    // engine unable to parse v1 payloads at runtime.\n    private static ensureDefaults(): void {\n        if (GatePayloadParsers.defaultsRegistered) {\n            return;\n        }\n        GatePayloadParsers.defaultsRegistered = true;\n        GatePayloadParsers.registry.register(1, GatePayloadSchemaV1.parse);\n    }\n\n    static register(engineVersion: number, parser: GatePayloadParser): void {\n        GatePayloadParsers.ensureDefaults();\n        GatePayloadParsers.registry.register(engineVersion, parser);\n    }\n\n    static get(engineVersion: number): GatePayloadParser | undefined {\n        GatePayloadParsers.ensureDefaults();\n        return GatePayloadParsers.registry.get(engineVersion);\n    }\n\n    static parse(engineVersion: number, payload: unknown) {\n        GatePayloadParsers.ensureDefaults();\n        return GatePayloadParsers.registry.parse(engineVersion, payload);\n    }\n}\n\nexport type { GatePayload };\n","import { Result } from \"../../result/result.js\";\n\nimport type {\n    GateOutcome,\n    PolicyContext,\n    VersionedGateEngine,\n} from \"./gate-types.js\";\nimport { GatePayloadParsers } from \"./parse-gate-payload.js\";\n\nexport class GateEngineRegistry {\n    private readonly engines = new Map<number, VersionedGateEngine>();\n\n    register(engine: VersionedGateEngine): void {\n        this.engines.set(engine.version, engine);\n    }\n\n    get(version: number): VersionedGateEngine | undefined {\n        return this.engines.get(version);\n    }\n\n    evaluate(\n        version: number,\n        payload: unknown,\n        context: PolicyContext,\n    ): Result<GateOutcome, string> {\n        const engine = this.engines.get(version);\n        if (!engine) {\n            return Result.err(\n                `No gate engine registered for version \"${version}\"`,\n            );\n        }\n\n        const parsedPayload = GatePayloadParsers.parse(version, payload);\n        if (parsedPayload.isErr()) {\n            return Result.err(parsedPayload.errorOrNull()!);\n        }\n\n        return engine.evaluate(parsedPayload.getOrNull()!, context);\n    }\n}\n"],"mappings":"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"}
+{"version":3,"file":"gate-engine-registry.js","names":[],"sources":["../src/core/policies/engines/v1/compute/compute-payload.schema.ts","../src/core/policies/engines/parse-compute-payload.ts","../src/core/policies/engines/compute-engine-registry.ts","../src/core/policies/engines/compute-evaluator-registry.ts","../src/core/policies/engines/v1/compute/resolve-decision-table-v1.ts","../src/core/policies/engines/v1/compute/compute-engine-v1.ts","../src/core/policies/engines/compute-registry.ts","../src/core/policies/engines/parse-gate-payload.ts","../src/core/policies/engines/gate-engine-registry.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { Result } from \"../../../../result/result.js\";\n\nimport { conditionNodeSchema } from \"../condition-schema.js\";\nimport type { ConditionNode } from \"../condition-types.js\";\n\n// ─── Pattern 1: Params ──────────────────────────────────────────────────────\n\nexport interface ComputeParamsPayload {\n    readonly type: \"params\";\n    readonly data: Readonly<Record<string, unknown>>;\n}\n\n// ─── Pattern 2: Decision table ──────────────────────────────────────────────\n\nexport interface ComputeDecisionTableRule<R = unknown> {\n    readonly conditions: ConditionNode;\n    readonly result: R;\n}\n\nexport interface ComputeDecisionTablePayload<R = unknown> {\n    readonly type: \"decision-table\";\n    readonly rules: readonly ComputeDecisionTableRule<R>[];\n    readonly default: R;\n}\n\n// ─── Union ──────────────────────────────────────────────────────────────────\n\nexport type ComputePayloadV1 =\n    | ComputeDecisionTablePayload<unknown>\n    | ComputeParamsPayload;\n\n// ─── Zod schemas ────────────────────────────────────────────────────────────\n\nconst computeDecisionTableRuleSchema = z.object({\n    conditions: conditionNodeSchema,\n    result: z.unknown(),\n});\n\nexport class ComputePayloadSchemaV1 {\n    static readonly schema = z.union([\n        z\n            .object({\n                type: z.literal(\"decision-table\"),\n                rules: z.array(computeDecisionTableRuleSchema).min(1),\n                default: z.unknown(),\n            })\n            .strict(),\n        z\n            .object({\n                type: z.literal(\"params\"),\n                data: z.record(z.string(), z.unknown()),\n            })\n            .strict(),\n    ]);\n\n    static parse(payload: unknown): Result<ComputePayloadV1, string> {\n        const parsed = ComputePayloadSchemaV1.schema.safeParse(payload);\n        if (!parsed.success) {\n            const details = parsed.error.issues\n                .map((issue) => {\n                    const path = issue.path.join(\".\");\n                    return path.length > 0\n                        ? `${path}: ${issue.message}`\n                        : issue.message;\n                })\n                .join(\"; \");\n\n            return Result.err(`Invalid compute payload: ${details}`);\n        }\n\n        return Result.ok(parsed.data as ComputePayloadV1);\n    }\n}\n\nexport const computePayloadSchema = ComputePayloadSchemaV1.schema;\n","import type { Result as ResultType } from \"../../result/result.js\";\nimport { Result } from \"../../result/result.js\";\n\nimport type { ComputePayload } from \"./compute-payload.js\";\nimport { ComputePayloadSchemaV1 } from \"./v1/compute/compute-payload.schema.js\";\n\nexport type ComputePayloadParser = (\n    payload: unknown,\n) => ResultType<ComputePayload, string>;\n\nexport class ComputePayloadParserRegistry {\n    private readonly parsers = new Map<number, ComputePayloadParser>();\n\n    register(payloadSchemaVersion: number, parser: ComputePayloadParser): void {\n        this.parsers.set(payloadSchemaVersion, parser);\n    }\n\n    get(payloadSchemaVersion: number): ComputePayloadParser | undefined {\n        return this.parsers.get(payloadSchemaVersion);\n    }\n\n    parse(payloadSchemaVersion: number, payload: unknown) {\n        const parser = this.parsers.get(payloadSchemaVersion);\n\n        if (parser === undefined) {\n            return Result.err(\n                `No compute payload parser registered for schema version \"${payloadSchemaVersion}\"`,\n            );\n        }\n\n        return parser(payload);\n    }\n}\n\nexport class ComputePayloadParsers {\n    private static readonly registry = new ComputePayloadParserRegistry();\n    private static defaultsRegistered = false;\n\n    // Registers the built-in v1 parser lazily, the first time the default\n    // dispatcher is touched. Done here — rather than as a top-level module\n    // statement — so the package's `\"sideEffects\": false` flag stays honest and\n    // a tree-shaking bundler cannot drop the v1 registration and leave the\n    // compute engine unable to parse v1 payloads at runtime.\n    private static ensureDefaults(): void {\n        if (ComputePayloadParsers.defaultsRegistered) {\n            return;\n        }\n        ComputePayloadParsers.defaultsRegistered = true;\n        ComputePayloadParsers.registry.register(\n            1,\n            ComputePayloadSchemaV1.parse,\n        );\n    }\n\n    static register(\n        payloadSchemaVersion: number,\n        parser: ComputePayloadParser,\n    ): void {\n        ComputePayloadParsers.ensureDefaults();\n        ComputePayloadParsers.registry.register(payloadSchemaVersion, parser);\n    }\n\n    static get(payloadSchemaVersion: number): ComputePayloadParser | undefined {\n        ComputePayloadParsers.ensureDefaults();\n        return ComputePayloadParsers.registry.get(payloadSchemaVersion);\n    }\n\n    static parse(payloadSchemaVersion: number, payload: unknown) {\n        ComputePayloadParsers.ensureDefaults();\n        return ComputePayloadParsers.registry.parse(\n            payloadSchemaVersion,\n            payload,\n        );\n    }\n}\n\nexport type { ComputePayload };\n","import { Result } from \"../../result/result.js\";\n\nimport type { PolicyContext } from \"./gate-types.js\";\nimport { ComputePayloadParsers } from \"./parse-compute-payload.js\";\nimport type { ComputeEvaluatorRegistry } from \"./compute-evaluator-registry.js\";\nimport type {\n    ComputeOutcome,\n    VersionedComputeEngine,\n} from \"./compute-types.js\";\n\nexport class ComputeEngineRegistry {\n    private readonly engines = new Map<number, VersionedComputeEngine>();\n\n    register(engine: VersionedComputeEngine): void {\n        this.engines.set(engine.version, engine);\n    }\n\n    get(version: number): VersionedComputeEngine | undefined {\n        return this.engines.get(version);\n    }\n\n    evaluate(\n        version: number,\n        params: {\n            readonly policyKey: string;\n            readonly payloadSchemaVersion: number;\n            readonly payload: unknown;\n            readonly context: PolicyContext;\n            readonly evaluators: ComputeEvaluatorRegistry;\n        },\n    ): Result<ComputeOutcome, string> {\n        const engine = this.get(version);\n        if (engine === undefined) {\n            return Result.err(\n                `No compute engine registered for version \"${version}\"`,\n            );\n        }\n\n        const evaluator = params.evaluators.get(params.policyKey, version);\n        if (evaluator === undefined) {\n            return Result.err(\n                `No compute evaluator registered for policy key \"${params.policyKey}\" and version \"${version}\"`,\n            );\n        }\n\n        const parsedPayloadResult = ComputePayloadParsers.parse(\n            params.payloadSchemaVersion,\n            params.payload,\n        );\n        if (parsedPayloadResult.isErr()) {\n            return Result.err(parsedPayloadResult.errorOrNull()!);\n        }\n\n        return engine.evaluate(\n            parsedPayloadResult.getOrNull()!,\n            params.context,\n            evaluator,\n        );\n    }\n}\n","import type {\n    ComputeEvaluator,\n    ComputeEvaluatorRegistration,\n} from \"./compute-types.js\";\n\nexport class ComputeEvaluatorRegistry {\n    private readonly evaluators = new Map<string, ComputeEvaluator>();\n\n    private static toRegistryKey(policyKey: string, version: number): string {\n        return `${policyKey}::${version}`;\n    }\n\n    register(registration: ComputeEvaluatorRegistration): void {\n        this.evaluators.set(\n            ComputeEvaluatorRegistry.toRegistryKey(\n                registration.policyKey,\n                registration.version,\n            ),\n            registration.evaluator,\n        );\n    }\n\n    get(policyKey: string, version: number): ComputeEvaluator | undefined {\n        return this.evaluators.get(\n            ComputeEvaluatorRegistry.toRegistryKey(policyKey, version),\n        );\n    }\n}\n","import { Result } from \"../../../../result/result.js\";\n\nimport type { ConditionEvaluationOptions } from \"../../condition-evaluator-reporter.js\";\n\nimport { ConditionEvaluatorV1 } from \"../condition-evaluator.js\";\nimport type { ComputeDecisionTablePayload } from \"./compute-payload.schema.js\";\n\nconst COMPUTE_CONDITION_EVAL_FAILED_TAG = \"COMPUTE_CONDITION_EVAL_FAILED\";\n\nexport class DecisionTableResolverV1 {\n    constructor(\n        private readonly payload: ComputeDecisionTablePayload,\n        private readonly context: Record<string, unknown>,\n        private readonly conditionEvaluationOptions: ConditionEvaluationOptions,\n    ) {}\n\n    private wrapConditionEvaluationError(\n        error: string,\n    ): Result<unknown, string> {\n        return Result.err(`${COMPUTE_CONDITION_EVAL_FAILED_TAG}: ${error}`);\n    }\n\n    resolve(): Result<unknown, string> {\n        const evaluator = new ConditionEvaluatorV1(\n            this.context,\n            this.conditionEvaluationOptions,\n        );\n\n        for (const rule of this.payload.rules) {\n            const conditionResult = evaluator.evaluate(rule.conditions);\n            if (conditionResult.isErr()) {\n                return this.wrapConditionEvaluationError(\n                    conditionResult.errorOrNull()!,\n                );\n            }\n\n            if (conditionResult.getOrNull()) {\n                return Result.ok(rule.result);\n            }\n        }\n\n        return Result.ok(this.payload.default);\n    }\n\n    static resolve(\n        payload: ComputeDecisionTablePayload,\n        context: Record<string, unknown>,\n        conditionEvaluationOptions: ConditionEvaluationOptions,\n    ): Result<unknown, string> {\n        return new DecisionTableResolverV1(\n            payload,\n            context,\n            conditionEvaluationOptions,\n        ).resolve();\n    }\n}\n","import { type CoreConfig, coreConfig } from \"../../../../config/index.js\";\nimport { Result } from \"../../../../result/result.js\";\n\nimport type { ComputePayloadV1 as ComputePayload } from \"./compute-payload.schema.js\";\nimport { DecisionTableResolverV1 } from \"./resolve-decision-table-v1.js\";\nimport type {\n    ComputeEvaluator,\n    ComputeOutcome,\n    VersionedComputeEngine,\n} from \"../../compute-types.js\";\nimport type { PolicyContext } from \"../../gate-types.js\";\n\n// ─── Compute engine v1 ───────────────────────────────────────────────────────\n\nconst COMPUTE_ENGINE_VERSION = 1;\n\nexport class ComputeEngineV1 implements VersionedComputeEngine {\n    readonly version = COMPUTE_ENGINE_VERSION;\n    private readonly coreConfig: CoreConfig;\n\n    constructor(params: { readonly coreConfig?: CoreConfig } = {}) {\n        this.coreConfig = params.coreConfig ?? coreConfig;\n    }\n\n    /**\n     * Evaluates an already-parsed ComputePayload against a context.\n     * Pure function — no side effects.\n     *\n     * For `params`: forwards `payload.data` directly to the evaluator.\n     * For `decision-table`: evaluates the rules in order and passes the `result`\n     * of the first one that satisfies its conditions, or `default` if none match.\n     *\n     * The evaluator is responsible for validating and transforming the final value.\n     */\n    evaluate(\n        payload: ComputePayload,\n        context: PolicyContext,\n        evaluator: ComputeEvaluator,\n    ): Result<ComputeOutcome, string> {\n        if (payload.type === \"params\") {\n            return evaluator.evaluate(payload.data, context);\n        }\n\n        const resolvedResult = DecisionTableResolverV1.resolve(\n            payload,\n            context,\n            this.coreConfig.getConditionEvaluationOptions(\n                COMPUTE_ENGINE_VERSION,\n            ),\n        );\n        if (resolvedResult.isErr()) {\n            return Result.err(resolvedResult.errorOrNull()!);\n        }\n\n        return evaluator.evaluate(resolvedResult.getOrNull()!, context);\n    }\n}\n","import { type CoreConfig, coreConfig } from \"../../config/index.js\";\nimport type { Result } from \"../../result/result.js\";\n\nimport { ComputeEngineRegistry } from \"./compute-engine-registry.js\";\nimport { ComputeEvaluatorRegistry } from \"./compute-evaluator-registry.js\";\nimport type { PolicyContext } from \"./gate-types.js\";\nimport type {\n    ComputeEvaluator,\n    ComputeEvaluatorRegistration,\n    ComputeOutcome,\n    VersionedComputeEngine,\n} from \"./compute-types.js\";\nimport { ComputeEngineV1 } from \"./v1/compute/index.js\";\n\nexport interface ComputeRegistryOptions {\n    readonly coreConfig?: CoreConfig;\n}\n\nexport class ComputeRegistry {\n    private readonly engines = new ComputeEngineRegistry();\n    private readonly evaluators = new ComputeEvaluatorRegistry();\n\n    constructor(params: ComputeRegistryOptions = {}) {\n        const resolvedCoreConfig = params.coreConfig ?? coreConfig;\n\n        this.engines.register(\n            new ComputeEngineV1({\n                coreConfig: resolvedCoreConfig,\n            }),\n        );\n    }\n\n    register(registration: ComputeEvaluatorRegistration): void {\n        this.evaluators.register(registration);\n    }\n\n    registerEngine(engine: VersionedComputeEngine): void {\n        this.engines.register(engine);\n    }\n\n    getEngine(version: number): VersionedComputeEngine | undefined {\n        return this.engines.get(version);\n    }\n\n    getEvaluator(\n        policyKey: string,\n        version: number,\n    ): ComputeEvaluator | undefined {\n        return this.evaluators.get(policyKey, version);\n    }\n\n    evaluate(\n        policyKey: string,\n        computeEngineVersion: number,\n        payloadSchemaVersion: number,\n        payload: unknown,\n        context: PolicyContext,\n    ): Result<ComputeOutcome, string> {\n        return this.engines.evaluate(computeEngineVersion, {\n            policyKey,\n            payloadSchemaVersion,\n            payload,\n            context,\n            evaluators: this.evaluators,\n        });\n    }\n}\n","import type { Result as ResultType } from \"../../result/result.js\";\nimport { Result } from \"../../result/result.js\";\n\nimport type { GatePayload } from \"./gate-payload.js\";\nimport { GatePayloadSchemaV1 } from \"./v1/gate/gate-v1-payload.schema.js\";\n\nexport type GatePayloadParser = (\n    payload: unknown,\n) => ResultType<GatePayload, string>;\n\nexport class GatePayloadParserRegistry {\n    private readonly parsers = new Map<number, GatePayloadParser>();\n\n    register(engineVersion: number, parser: GatePayloadParser): void {\n        this.parsers.set(engineVersion, parser);\n    }\n\n    get(engineVersion: number): GatePayloadParser | undefined {\n        return this.parsers.get(engineVersion);\n    }\n\n    parse(engineVersion: number, payload: unknown) {\n        const parser = this.parsers.get(engineVersion);\n\n        if (parser === undefined) {\n            return Result.err(\n                `No gate payload parser registered for engine version \"${engineVersion}\"`,\n            );\n        }\n\n        return parser(payload);\n    }\n}\n\nexport class GatePayloadParsers {\n    private static readonly registry = new GatePayloadParserRegistry();\n    private static defaultsRegistered = false;\n\n    // Registers the built-in v1 parser lazily, the first time the default\n    // dispatcher is touched. Done here — rather than as a top-level module\n    // statement — so the package's `\"sideEffects\": false` flag stays honest and\n    // a tree-shaking bundler cannot drop the v1 registration and leave the gate\n    // engine unable to parse v1 payloads at runtime.\n    private static ensureDefaults(): void {\n        if (GatePayloadParsers.defaultsRegistered) {\n            return;\n        }\n        GatePayloadParsers.defaultsRegistered = true;\n        GatePayloadParsers.registry.register(1, GatePayloadSchemaV1.parse);\n    }\n\n    static register(engineVersion: number, parser: GatePayloadParser): void {\n        GatePayloadParsers.ensureDefaults();\n        GatePayloadParsers.registry.register(engineVersion, parser);\n    }\n\n    static get(engineVersion: number): GatePayloadParser | undefined {\n        GatePayloadParsers.ensureDefaults();\n        return GatePayloadParsers.registry.get(engineVersion);\n    }\n\n    static parse(engineVersion: number, payload: unknown) {\n        GatePayloadParsers.ensureDefaults();\n        return GatePayloadParsers.registry.parse(engineVersion, payload);\n    }\n}\n\nexport type { GatePayload };\n","import { Result } from \"../../result/result.js\";\n\nimport type {\n    GateOutcome,\n    PolicyContext,\n    VersionedGateEngine,\n} from \"./gate-types.js\";\nimport { GatePayloadParsers } from \"./parse-gate-payload.js\";\n\nexport class GateEngineRegistry {\n    private readonly engines = new Map<number, VersionedGateEngine>();\n\n    register(engine: VersionedGateEngine): void {\n        this.engines.set(engine.version, engine);\n    }\n\n    get(version: number): VersionedGateEngine | undefined {\n        return this.engines.get(version);\n    }\n\n    evaluate(\n        version: number,\n        payload: unknown,\n        context: PolicyContext,\n    ): Result<GateOutcome, string> {\n        const engine = this.engines.get(version);\n        if (!engine) {\n            return Result.err(\n                `No gate engine registered for version \"${version}\"`,\n            );\n        }\n\n        const parsedPayload = GatePayloadParsers.parse(version, payload);\n        if (parsedPayload.isErr()) {\n            return Result.err(parsedPayload.errorOrNull()!);\n        }\n\n        return engine.evaluate(parsedPayload.getOrNull()!, context);\n    }\n}\n"],"mappings":"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"}