@cullet/erp-core 1.0.0

package/KIT_CONTEXT.md

@@ -0,0 +1,39 @@
+# erp-core — KIT_CONTEXT
+
+## [purpose] Propósito
+
+Núcleo arquitetural para sistemas ERP (e domínios transacionais com temporalidade). Resolve o problema de começar um core de negócio com entidades, value objects, policies, tratamento de erros e services de aplicação já desenhados em clean architecture, sem amarrar a framework.
+
+## [layers] Camadas
+
+- **`domain/`** — `Entity`, `ValueObject`. Pura: zero dependência de runtime externo. Invariantes lançam exceções tipadas.
+- **`exceptions/`** — hierarquia de exceções de domínio (`DomainException`, `InvariantViolationException`, `InvalidStateTransitionException`, `ValidationException`, `BusinessRuleViolationException`, `EntityNotFoundException`).
+- **`errors/`** — erros de aplicação (`AppError` e descendentes: `ValidationError`, `NotFoundError`, `ConflictError`, `AuthorizationError`, `IntegrationError`, etc.). Carregam `code` discriminado.
+- **`result/`** — `Result<T, E>` e `Outcome` para retorno tipado da camada de aplicação.
+- **`application/`** — `UseCase` base, `commands/`, `queries/`, `ports/`. Casos de uso consomem portas e retornam `Result`.
+- **`policies/`** — catálogo, definições, resolução e avaliação de policies declarativas.
+- **`versioning/`** — utilidades de versionamento de agregados temporais.
+
+## [key-decisions] Decisões-chave
+
+- **Domínio lança, aplicação retorna `Result`, infra traduz.** Não há `Result` no domínio.
+- **Sem lib de log/observabilidade no runtime.** Portas vivem em `application/ports/`; adapters são opt-in.
+- **Temporalidade interna ao kit** — o kit mantém suporte temporal no código-base, mas a API pública principal nao publica um `Timeline<T>` nem helpers temporais dedicados no barrel raiz.
+- **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.
+
+## [extension-points] Pontos de extensão
+
+Implemente as portas em `application/ports/` para conectar a stack real:
+
+- `LoggerPort`, `MetricsPort`, `TracerPort` — observabilidade.
+- Repositórios específicos do seu domínio, sempre com verbo mínimo.
+- `AuthorizerPort` / `AuthenticatorPort` quando aplicável.
+
+## [non-goals] Não-objetivos
+
+- **Não é ORM.** Nenhuma mágica de mapeamento, nenhum decorator de persistência.
+- **Não é framework HTTP.** Não fornece controllers, roteamento, middleware.
+- **Não é runtime de workflow.** Sagas, schedulers, filas: fora do escopo — devem ser kits separados.
+- **Não impõe stack de teste.** As specs usam Vitest aqui, mas o desenho não depende disso.

package/README.md

@@ -0,0 +1,110 @@
+# erp-core
+
+Núcleo arquitetural para sistemas ERP e domínios transacionais. Primitives tipadas para domínio, policies, erros e application services com clean architecture pronta para receber adapters.
+
+Para o sumário prompt-friendly veja [`KIT_CONTEXT.md`](./KIT_CONTEXT.md). Para os contratos comuns a todos os kits veja a [`PHILOSOPHY.md`](../../../../PHILOSOPHY.md).
+
+---
+
+## O que entrega
+
+- **Domínio** — `Entity`, `ValueObject`.
+- **Exceções de domínio** — `DomainException`, `InvariantViolationException`, `InvalidStateTransitionException`, `ValidationException`, `BusinessRuleViolationException`, `EntityNotFoundException`.
+- **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.
+- **Exemplos** — rulesets de referência em `examples/rulesets/`, fora da superfície principal de domínio.
+
+## Como começa
+
+Import direto (sempre a versão `latest` exportada pelo pacote):
+
+```ts
+import {
+  Entity,
+  ValueObject,
+  PolicyCatalog,
+  PolicyService,
+  mapPolicyEvaluationError,
+  type PolicyDecision,
+} from "@cullet/erp-core";
+```
+
+Pinado em uma versão (recomendado em produção): fixe a versão npm do pacote no
+seu `package.json` (ex.: `"@cullet/erp-core": "1.0.0"`).
+
+```ts
+import { PolicyResolver } from "@cullet/erp-core";
+```
+
+Full-control (kit copiado para dentro do projeto, livre para editar):
+
+```bash
+npx cullet fc @cullet/erp-core@1.0.0
+```
+
+## Composicao sem singletons
+
+Para isolamento por tenant, request ou teste, prefira instancias locais em vez
+dos exports globais `coreConfig` e `contextResolverRegistry`:
+
+```ts
+import {
+  ComputeRegistry,
+  ContextResolverRegistry,
+  CoreConfig,
+  GateEngineRegistry,
+  PolicyContextBuilder,
+  Result,
+  registerNamespacedContextResolversIn,
+} from "@cullet/erp-core";
+import { GateEngineV1 } from "@cullet/erp-core/policies/engines/v1/gate";
+
+const coreConfig = new CoreConfig({
+  observability: { reporter },
+});
+
+const resolverRegistry = new ContextResolverRegistry();
+registerNamespacedContextResolversIn(resolverRegistry, "billing", [
+  {
+    path: "student.contractStatus",
+    resilience: {
+      timeoutMs: 200,
+      retry: { maxAttempts: 3, initialDelayMs: 25, maxDelayMs: 100 },
+      circuitBreaker: { failureThreshold: 5, cooldownMs: 1_000 },
+    },
+    async resolve(seed) {
+      return Result.ok(seed.fields.contractStatus);
+    },
+  },
+]);
+
+const contextBuilder = new PolicyContextBuilder(resolverRegistry);
+
+const gateEngines = new GateEngineRegistry();
+gateEngines.register(new GateEngineV1({ coreConfig }));
+
+const computeRegistry = new ComputeRegistry({ coreConfig });
+```
+
+Os singletons continuam disponiveis para apps simples, mas nao sao o caminho
+recomendado quando ha risco de bleed entre composicoes concorrentes.
+
+## Decisões tomadas
+
+- **Modelo de erro `mixed`**: domínio lança `DomainException`, aplicação retorna `Result<T, AppError>`, infra traduz para `Result`. Não cruze a fronteira.
+- **Temporalidade interna ao kit**: o suporte temporal continua no código do kit, mas a API pública principal não expõe um container `Timeline<T>` nem helpers temporais dedicados no barrel raiz.
+- **Policies como dados**: catalogadas, resolvidas e avaliadas por `PolicyCatalog`, `PolicyResolver` e `PolicyService`. Não são `if`s espalhados pela aplicação.
+- **Disable first-class para definitions**: `PolicyDefinition` aceita `enabled: false` para desligar uma definicao sem removê-la do repositório; o default continua `true`.
+- **Observabilidade só via portas**: `LoggerPort`, `MetricsPort`, `TracerPort` em `core/application/ports/`. Sem dependência runtime de `pino`, `winston`, OpenTelemetry no kit.
+- **Dependência runtime declarada**: `zod` (validação tipada). Em modo full-control, instale manualmente — o `cullet doctor` e o `cullet fc` te avisam.
+
+## Como evoluir
+
+- **Novos use cases**: criar em `core/application/` consumindo portas existentes; nunca importar de `adapters/`.
+- **Novas portas**: interface em `core/application/ports/`, implementação em `adapters/<lib>/`, sem vazar tipos da lib externa.
+- **Novas exceções de domínio**: derive de `DomainException` em `core/exceptions/`.
+- **Novos erros de aplicação**: derive de `AppError` e adicione o `code` discriminado em `core/errors/`.
+- **Mudança incompatível**: abra `versions/2.0.0/`. Regras em [`kits/VERSIONING.md`](../../../../kits/VERSIONING.md).
+- **Antes de publicar**: `npm run validate-kits` para garantir aderência à filosofia.

package/dist/errors/index.d.ts

@@ -0,0 +1,2 @@
+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";
+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

@@ -0,0 +1,3 @@
+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";
+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/validation-field.d.ts

@@ -0,0 +1,2 @@
+import { t as ValidationField } from "../validation-field.js";
+export { ValidationField };

package/dist/exceptions/validation-field.js

@@ -0,0 +1,2 @@
+import { t as ValidationField } from "../validation-field.js";
+export { ValidationField };

package/dist/gate-engine-registry.js

@@ -0,0 +1,260 @@
+import { a as conditionNodeSchema, l as Result, r as ConditionEvaluatorV1, t as GatePayloadSchemaV1, u as coreConfig } from "./gate-v1-payload.schema.js";
+import { z } from "zod";
+//#region src/core/policies/engines/v1/compute/compute-payload.schema.ts
+const computeDecisionTableRuleSchema = z.object({
+	conditions: conditionNodeSchema,
+	result: z.unknown()
+});
+var ComputePayloadSchemaV1 = class ComputePayloadSchemaV1 {
+	static {
+		this.schema = z.union([z.object({
+			type: z.literal("decision-table"),
+			rules: z.array(computeDecisionTableRuleSchema).min(1),
+			default: z.unknown()
+		}).strict(), z.object({
+			type: z.literal("params"),
+			data: z.record(z.string(), z.unknown())
+		}).strict()]);
+	}
+	static parse(payload) {
+		const parsed = ComputePayloadSchemaV1.schema.safeParse(payload);
+		if (!parsed.success) {
+			const details = parsed.error.issues.map((issue) => {
+				const path = issue.path.join(".");
+				return path.length > 0 ? `${path}: ${issue.message}` : issue.message;
+			}).join("; ");
+			return Result.err(`Invalid compute payload: ${details}`);
+		}
+		return Result.ok(parsed.data);
+	}
+};
+ComputePayloadSchemaV1.schema;
+//#endregion
+//#region src/core/policies/engines/parse-compute-payload.ts
+var ComputePayloadParserRegistry = class {
+	constructor() {
+		this.parsers = /* @__PURE__ */ new Map();
+	}
+	register(payloadSchemaVersion, parser) {
+		this.parsers.set(payloadSchemaVersion, parser);
+	}
+	get(payloadSchemaVersion) {
+		return this.parsers.get(payloadSchemaVersion);
+	}
+	parse(payloadSchemaVersion, payload) {
+		const parser = this.parsers.get(payloadSchemaVersion);
+		if (parser === void 0) return Result.err(`No compute payload parser registered for schema version "${payloadSchemaVersion}"`);
+		return parser(payload);
+	}
+};
+var ComputePayloadParsers = class ComputePayloadParsers {
+	static {
+		this.registry = new ComputePayloadParserRegistry();
+	}
+	static {
+		this.defaultsRegistered = false;
+	}
+	static ensureDefaults() {
+		if (ComputePayloadParsers.defaultsRegistered) return;
+		ComputePayloadParsers.defaultsRegistered = true;
+		ComputePayloadParsers.registry.register(1, ComputePayloadSchemaV1.parse);
+	}
+	static register(payloadSchemaVersion, parser) {
+		ComputePayloadParsers.ensureDefaults();
+		ComputePayloadParsers.registry.register(payloadSchemaVersion, parser);
+	}
+	static get(payloadSchemaVersion) {
+		ComputePayloadParsers.ensureDefaults();
+		return ComputePayloadParsers.registry.get(payloadSchemaVersion);
+	}
+	static parse(payloadSchemaVersion, payload) {
+		ComputePayloadParsers.ensureDefaults();
+		return ComputePayloadParsers.registry.parse(payloadSchemaVersion, payload);
+	}
+};
+//#endregion
+//#region src/core/policies/engines/compute-engine-registry.ts
+var ComputeEngineRegistry = class {
+	constructor() {
+		this.engines = /* @__PURE__ */ new Map();
+	}
+	register(engine) {
+		this.engines.set(engine.version, engine);
+	}
+	get(version) {
+		return this.engines.get(version);
+	}
+	evaluate(version, params) {
+		const engine = this.get(version);
+		if (engine === void 0) return Result.err(`No compute engine registered for version "${version}"`);
+		const evaluator = params.evaluators.get(params.policyKey, version);
+		if (evaluator === void 0) return Result.err(`No compute evaluator registered for policy key "${params.policyKey}" and version "${version}"`);
+		const parsedPayloadResult = ComputePayloadParsers.parse(params.payloadSchemaVersion, params.payload);
+		if (parsedPayloadResult.isErr()) return Result.err(parsedPayloadResult.errorOrNull());
+		return engine.evaluate(parsedPayloadResult.getOrNull(), params.context, evaluator);
+	}
+};
+//#endregion
+//#region src/core/policies/engines/compute-evaluator-registry.ts
+var ComputeEvaluatorRegistry = class ComputeEvaluatorRegistry {
+	constructor() {
+		this.evaluators = /* @__PURE__ */ new Map();
+	}
+	static toRegistryKey(policyKey, version) {
+		return `${policyKey}::${version}`;
+	}
+	register(registration) {
+		this.evaluators.set(ComputeEvaluatorRegistry.toRegistryKey(registration.policyKey, registration.version), registration.evaluator);
+	}
+	get(policyKey, version) {
+		return this.evaluators.get(ComputeEvaluatorRegistry.toRegistryKey(policyKey, version));
+	}
+};
+//#endregion
+//#region src/core/policies/engines/v1/compute/resolve-decision-table-v1.ts
+const COMPUTE_CONDITION_EVAL_FAILED_TAG = "COMPUTE_CONDITION_EVAL_FAILED";
+var DecisionTableResolverV1 = class DecisionTableResolverV1 {
+	constructor(payload, context, conditionEvaluationOptions) {
+		this.payload = payload;
+		this.context = context;
+		this.conditionEvaluationOptions = conditionEvaluationOptions;
+	}
+	wrapConditionEvaluationError(error) {
+		return Result.err(`${COMPUTE_CONDITION_EVAL_FAILED_TAG}: ${error}`);
+	}
+	resolve() {
+		const evaluator = new ConditionEvaluatorV1(this.context, this.conditionEvaluationOptions);
+		for (const rule of this.payload.rules) {
+			const conditionResult = evaluator.evaluate(rule.conditions);
+			if (conditionResult.isErr()) return this.wrapConditionEvaluationError(conditionResult.errorOrNull());
+			if (conditionResult.getOrNull()) return Result.ok(rule.result);
+		}
+		return Result.ok(this.payload.default);
+	}
+	static resolve(payload, context, conditionEvaluationOptions) {
+		return new DecisionTableResolverV1(payload, context, conditionEvaluationOptions).resolve();
+	}
+};
+//#endregion
+//#region src/core/policies/engines/v1/compute/compute-engine-v1.ts
+const COMPUTE_ENGINE_VERSION = 1;
+var ComputeEngineV1 = class {
+	constructor(params = {}) {
+		this.version = COMPUTE_ENGINE_VERSION;
+		this.coreConfig = params.coreConfig ?? coreConfig;
+	}
+	/**
+	* Evaluates an already-parsed ComputePayload against a context.
+	* Pure function — no side effects.
+	*
+	* For `params`: forwards `payload.data` directly to the evaluator.
+	* For `decision-table`: evaluates the rules in order and passes the `result`
+	* of the first one that satisfies its conditions, or `default` if none match.
+	*
+	* The evaluator is responsible for validating and transforming the final value.
+	*/
+	evaluate(payload, context, evaluator) {
+		if (payload.type === "params") return evaluator.evaluate(payload.data, context);
+		const resolvedResult = DecisionTableResolverV1.resolve(payload, context, this.coreConfig.getConditionEvaluationOptions(COMPUTE_ENGINE_VERSION));
+		if (resolvedResult.isErr()) return Result.err(resolvedResult.errorOrNull());
+		return evaluator.evaluate(resolvedResult.getOrNull(), context);
+	}
+};
+//#endregion
+//#region src/core/policies/engines/compute-registry.ts
+var ComputeRegistry = class {
+	constructor(params = {}) {
+		this.engines = new ComputeEngineRegistry();
+		this.evaluators = new ComputeEvaluatorRegistry();
+		const resolvedCoreConfig = params.coreConfig ?? coreConfig;
+		this.engines.register(new ComputeEngineV1({ coreConfig: resolvedCoreConfig }));
+	}
+	register(registration) {
+		this.evaluators.register(registration);
+	}
+	registerEngine(engine) {
+		this.engines.register(engine);
+	}
+	getEngine(version) {
+		return this.engines.get(version);
+	}
+	getEvaluator(policyKey, version) {
+		return this.evaluators.get(policyKey, version);
+	}
+	evaluate(policyKey, computeEngineVersion, payloadSchemaVersion, payload, context) {
+		return this.engines.evaluate(computeEngineVersion, {
+			policyKey,
+			payloadSchemaVersion,
+			payload,
+			context,
+			evaluators: this.evaluators
+		});
+	}
+};
+//#endregion
+//#region src/core/policies/engines/parse-gate-payload.ts
+var GatePayloadParserRegistry = class {
+	constructor() {
+		this.parsers = /* @__PURE__ */ new Map();
+	}
+	register(engineVersion, parser) {
+		this.parsers.set(engineVersion, parser);
+	}
+	get(engineVersion) {
+		return this.parsers.get(engineVersion);
+	}
+	parse(engineVersion, payload) {
+		const parser = this.parsers.get(engineVersion);
+		if (parser === void 0) return Result.err(`No gate payload parser registered for engine version "${engineVersion}"`);
+		return parser(payload);
+	}
+};
+var GatePayloadParsers = class GatePayloadParsers {
+	static {
+		this.registry = new GatePayloadParserRegistry();
+	}
+	static {
+		this.defaultsRegistered = false;
+	}
+	static ensureDefaults() {
+		if (GatePayloadParsers.defaultsRegistered) return;
+		GatePayloadParsers.defaultsRegistered = true;
+		GatePayloadParsers.registry.register(1, GatePayloadSchemaV1.parse);
+	}
+	static register(engineVersion, parser) {
+		GatePayloadParsers.ensureDefaults();
+		GatePayloadParsers.registry.register(engineVersion, parser);
+	}
+	static get(engineVersion) {
+		GatePayloadParsers.ensureDefaults();
+		return GatePayloadParsers.registry.get(engineVersion);
+	}
+	static parse(engineVersion, payload) {
+		GatePayloadParsers.ensureDefaults();
+		return GatePayloadParsers.registry.parse(engineVersion, payload);
+	}
+};
+//#endregion
+//#region src/core/policies/engines/gate-engine-registry.ts
+var GateEngineRegistry = class {
+	constructor() {
+		this.engines = /* @__PURE__ */ new Map();
+	}
+	register(engine) {
+		this.engines.set(engine.version, engine);
+	}
+	get(version) {
+		return this.engines.get(version);
+	}
+	evaluate(version, payload, context) {
+		const engine = this.engines.get(version);
+		if (!engine) return Result.err(`No gate engine registered for version "${version}"`);
+		const parsedPayload = GatePayloadParsers.parse(version, payload);
+		if (parsedPayload.isErr()) return Result.err(parsedPayload.errorOrNull());
+		return engine.evaluate(parsedPayload.getOrNull(), context);
+	}
+};
+//#endregion
+export { ComputeEvaluatorRegistry as a, ComputePayloadParsers as c, ComputeRegistry as i, GatePayloadParserRegistry as n, ComputeEngineRegistry as o, GatePayloadParsers as r, ComputePayloadParserRegistry as s, GateEngineRegistry as t };
+
+//# sourceMappingURL=gate-engine-registry.js.map

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

@@ -0,0 +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\";\n\nimport { conditionNodeSchema } from \"../condition-schema\";\nimport type { ConditionNode } from \"../condition-types\";\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 ? `${path}: ${issue.message}` : 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\";\nimport { Result } from \"../../result/result\";\n\nimport type { ComputePayload } from \"./compute-payload\";\nimport { ComputePayloadSchemaV1 } from \"./v1/compute/compute-payload.schema\";\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(1, ComputePayloadSchemaV1.parse);\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(payloadSchemaVersion, payload);\n  }\n}\n\nexport type { ComputePayload };\n","import { Result } from \"../../result/result\";\n\nimport type { PolicyContext } from \"./gate-types\";\nimport { ComputePayloadParsers } from \"./parse-compute-payload\";\nimport type { ComputeEvaluatorRegistry } from \"./compute-evaluator-registry\";\nimport type { ComputeOutcome, VersionedComputeEngine } from \"./compute-types\";\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\";\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\";\n\nimport type { ConditionEvaluationOptions } from \"../../condition-evaluator-reporter\";\n\nimport { ConditionEvaluatorV1 } from \"../condition-evaluator\";\nimport type { ComputeDecisionTablePayload } from \"./compute-payload.schema\";\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(error: string): 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\";\nimport { Result } from \"../../../../result/result\";\n\nimport type { ComputePayloadV1 as ComputePayload } from \"./compute-payload.schema\";\nimport { DecisionTableResolverV1 } from \"./resolve-decision-table-v1\";\nimport type {\n  ComputeEvaluator,\n  ComputeOutcome,\n  VersionedComputeEngine,\n} from \"../../compute-types\";\nimport type { PolicyContext } from \"../../gate-types\";\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(COMPUTE_ENGINE_VERSION),\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\";\nimport type { Result } from \"../../result/result\";\n\nimport { ComputeEngineRegistry } from \"./compute-engine-registry\";\nimport { ComputeEvaluatorRegistry } from \"./compute-evaluator-registry\";\nimport type { PolicyContext } from \"./gate-types\";\nimport type {\n  ComputeEvaluator,\n  ComputeEvaluatorRegistration,\n  ComputeOutcome,\n  VersionedComputeEngine,\n} from \"./compute-types\";\nimport { ComputeEngineV1 } from \"./v1/compute\";\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\";\nimport { Result } from \"../../result/result\";\n\nimport type { GatePayload } from \"./gate-payload\";\nimport { GatePayloadSchemaV1 } from \"./v1/gate/gate-v1-payload.schema\";\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\";\n\nimport type {\n  GateOutcome,\n  PolicyContext,\n  VersionedGateEngine,\n} from \"./gate-types\";\nimport { GatePayloadParsers } from \"./parse-gate-payload\";\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(`No gate engine registered for version \"${version}\"`);\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":";;;AAmCA,MAAM,iCAAiC,EAAE,OAAO;CAC9C,YAAY;CACZ,QAAQ,EAAE,QAAQ;AACpB,CAAC;AAED,IAAa,yBAAb,MAAa,uBAAuB;;gBACT,EAAE,MAAM,CAC/B,EACG,OAAO;GACN,MAAM,EAAE,QAAQ,gBAAgB;GAChC,OAAO,EAAE,MAAM,8BAA8B,EAAE,IAAI,CAAC;GACpD,SAAS,EAAE,QAAQ;EACrB,CAAC,EACA,OAAO,GACV,EACG,OAAO;GACN,MAAM,EAAE,QAAQ,QAAQ;GACxB,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,QAAQ,CAAC;EACxC,CAAC,EACA,OAAO,CACZ,CAAC;;CAED,OAAO,MAAM,SAAoD;EAC/D,MAAM,SAAS,uBAAuB,OAAO,UAAU,OAAO;EAC9D,IAAI,CAAC,OAAO,SAAS;GACnB,MAAM,UAAU,OAAO,MAAM,OAC1B,KAAK,UAAU;IACd,MAAM,OAAO,MAAM,KAAK,KAAK,GAAG;IAChC,OAAO,KAAK,SAAS,IAAI,GAAG,KAAK,IAAI,MAAM,YAAY,MAAM;GAC/D,CAAC,EACA,KAAK,IAAI;GAEZ,OAAO,OAAO,IAAI,4BAA4B,SAAS;EACzD;EAEA,OAAO,OAAO,GAAG,OAAO,IAAwB;CAClD;AACF;AAEoC,uBAAuB;;;AChE3D,IAAa,+BAAb,MAA0C;;iCACb,IAAI,IAAkC;;CAEjE,SAAS,sBAA8B,QAAoC;EACzE,KAAK,QAAQ,IAAI,sBAAsB,MAAM;CAC/C;CAEA,IAAI,sBAAgE;EAClE,OAAO,KAAK,QAAQ,IAAI,oBAAoB;CAC9C;CAEA,MAAM,sBAA8B,SAAkB;EACpD,MAAM,SAAS,KAAK,QAAQ,IAAI,oBAAoB;EAEpD,IAAI,WAAW,KAAA,GACb,OAAO,OAAO,IACZ,4DAA4D,qBAAqB,EACnF;EAGF,OAAO,OAAO,OAAO;CACvB;AACF;AAEA,IAAa,wBAAb,MAAa,sBAAsB;;kBACE,IAAI,6BAA6B;;;4BAChC;;CAOpC,OAAe,iBAAuB;EACpC,IAAI,sBAAsB,oBACxB;EAEF,sBAAsB,qBAAqB;EAC3C,sBAAsB,SAAS,SAAS,GAAG,uBAAuB,KAAK;CACzE;CAEA,OAAO,SACL,sBACA,QACM;EACN,sBAAsB,eAAe;EACrC,sBAAsB,SAAS,SAAS,sBAAsB,MAAM;CACtE;CAEA,OAAO,IAAI,sBAAgE;EACzE,sBAAsB,eAAe;EACrC,OAAO,sBAAsB,SAAS,IAAI,oBAAoB;CAChE;CAEA,OAAO,MAAM,sBAA8B,SAAkB;EAC3D,sBAAsB,eAAe;EACrC,OAAO,sBAAsB,SAAS,MAAM,sBAAsB,OAAO;CAC3E;AACF;;;AC7DA,IAAa,wBAAb,MAAmC;;iCACN,IAAI,IAAoC;;CAEnE,SAAS,QAAsC;EAC7C,KAAK,QAAQ,IAAI,OAAO,SAAS,MAAM;CACzC;CAEA,IAAI,SAAqD;EACvD,OAAO,KAAK,QAAQ,IAAI,OAAO;CACjC;CAEA,SACE,SACA,QAOgC;EAChC,MAAM,SAAS,KAAK,IAAI,OAAO;EAC/B,IAAI,WAAW,KAAA,GACb,OAAO,OAAO,IACZ,6CAA6C,QAAQ,EACvD;EAGF,MAAM,YAAY,OAAO,WAAW,IAAI,OAAO,WAAW,OAAO;EACjE,IAAI,cAAc,KAAA,GAChB,OAAO,OAAO,IACZ,mDAAmD,OAAO,UAAU,iBAAiB,QAAQ,EAC/F;EAGF,MAAM,sBAAsB,sBAAsB,MAChD,OAAO,sBACP,OAAO,OACT;EACA,IAAI,oBAAoB,MAAM,GAC5B,OAAO,OAAO,IAAI,oBAAoB,YAAY,CAAE;EAGtD,OAAO,OAAO,SACZ,oBAAoB,UAAU,GAC9B,OAAO,SACP,SACF;CACF;AACF;;;ACnDA,IAAa,2BAAb,MAAa,yBAAyB;;oCACN,IAAI,IAA8B;;CAEhE,OAAe,cAAc,WAAmB,SAAyB;EACvE,OAAO,GAAG,UAAU,IAAI;CAC1B;CAEA,SAAS,cAAkD;EACzD,KAAK,WAAW,IACd,yBAAyB,cACvB,aAAa,WACb,aAAa,OACf,GACA,aAAa,SACf;CACF;CAEA,IAAI,WAAmB,SAA+C;EACpE,OAAO,KAAK,WAAW,IACrB,yBAAyB,cAAc,WAAW,OAAO,CAC3D;CACF;AACF;;;ACpBA,MAAM,oCAAoC;AAE1C,IAAa,0BAAb,MAAa,wBAAwB;CACnC,YACE,SACA,SACA,4BACA;EAHiB,KAAA,UAAA;EACA,KAAA,UAAA;EACA,KAAA,6BAAA;CAChB;CAEH,6BAAqC,OAAwC;EAC3E,OAAO,OAAO,IAAI,GAAG,kCAAkC,IAAI,OAAO;CACpE;CAEA,UAAmC;EACjC,MAAM,YAAY,IAAI,qBACpB,KAAK,SACL,KAAK,0BACP;EAEA,KAAK,MAAM,QAAQ,KAAK,QAAQ,OAAO;GACrC,MAAM,kBAAkB,UAAU,SAAS,KAAK,UAAU;GAC1D,IAAI,gBAAgB,MAAM,GACxB,OAAO,KAAK,6BACV,gBAAgB,YAAY,CAC9B;GAGF,IAAI,gBAAgB,UAAU,GAC5B,OAAO,OAAO,GAAG,KAAK,MAAM;EAEhC;EAEA,OAAO,OAAO,GAAG,KAAK,QAAQ,OAAO;CACvC;CAEA,OAAO,QACL,SACA,SACA,4BACyB;EACzB,OAAO,IAAI,wBACT,SACA,SACA,0BACF,EAAE,QAAQ;CACZ;AACF;;;ACvCA,MAAM,yBAAyB;AAE/B,IAAa,kBAAb,MAA+D;CAI7D,YAAY,SAA+C,CAAC,GAAG;iBAH5C;EAIjB,KAAK,aAAa,OAAO,cAAc;CACzC;;;;;;;;;;;CAYA,SACE,SACA,SACA,WACgC;EAChC,IAAI,QAAQ,SAAS,UACnB,OAAO,UAAU,SAAS,QAAQ,MAAM,OAAO;EAGjD,MAAM,iBAAiB,wBAAwB,QAC7C,SACA,SACA,KAAK,WAAW,8BAA8B,sBAAsB,CACtE;EACA,IAAI,eAAe,MAAM,GACvB,OAAO,OAAO,IAAI,eAAe,YAAY,CAAE;EAGjD,OAAO,UAAU,SAAS,eAAe,UAAU,GAAI,OAAO;CAChE;AACF;;;ACpCA,IAAa,kBAAb,MAA6B;CAI3B,YAAY,SAAiC,CAAC,GAAG;iBAHtB,IAAI,sBAAsB;oBACvB,IAAI,yBAAyB;EAGzD,MAAM,qBAAqB,OAAO,cAAc;EAEhD,KAAK,QAAQ,SACX,IAAI,gBAAgB,EAClB,YAAY,mBACd,CAAC,CACH;CACF;CAEA,SAAS,cAAkD;EACzD,KAAK,WAAW,SAAS,YAAY;CACvC;CAEA,eAAe,QAAsC;EACnD,KAAK,QAAQ,SAAS,MAAM;CAC9B;CAEA,UAAU,SAAqD;EAC7D,OAAO,KAAK,QAAQ,IAAI,OAAO;CACjC;CAEA,aACE,WACA,SAC8B;EAC9B,OAAO,KAAK,WAAW,IAAI,WAAW,OAAO;CAC/C;CAEA,SACE,WACA,sBACA,sBACA,SACA,SACgC;EAChC,OAAO,KAAK,QAAQ,SAAS,sBAAsB;GACjD;GACA;GACA;GACA;GACA,YAAY,KAAK;EACnB,CAAC;CACH;AACF;;;ACxDA,IAAa,4BAAb,MAAuC;;iCACV,IAAI,IAA+B;;CAE9D,SAAS,eAAuB,QAAiC;EAC/D,KAAK,QAAQ,IAAI,eAAe,MAAM;CACxC;CAEA,IAAI,eAAsD;EACxD,OAAO,KAAK,QAAQ,IAAI,aAAa;CACvC;CAEA,MAAM,eAAuB,SAAkB;EAC7C,MAAM,SAAS,KAAK,QAAQ,IAAI,aAAa;EAE7C,IAAI,WAAW,KAAA,GACb,OAAO,OAAO,IACZ,yDAAyD,cAAc,EACzE;EAGF,OAAO,OAAO,OAAO;CACvB;AACF;AAEA,IAAa,qBAAb,MAAa,mBAAmB;;kBACK,IAAI,0BAA0B;;;4BAC7B;;CAOpC,OAAe,iBAAuB;EACpC,IAAI,mBAAmB,oBACrB;EAEF,mBAAmB,qBAAqB;EACxC,mBAAmB,SAAS,SAAS,GAAG,oBAAoB,KAAK;CACnE;CAEA,OAAO,SAAS,eAAuB,QAAiC;EACtE,mBAAmB,eAAe;EAClC,mBAAmB,SAAS,SAAS,eAAe,MAAM;CAC5D;CAEA,OAAO,IAAI,eAAsD;EAC/D,mBAAmB,eAAe;EAClC,OAAO,mBAAmB,SAAS,IAAI,aAAa;CACtD;CAEA,OAAO,MAAM,eAAuB,SAAkB;EACpD,mBAAmB,eAAe;EAClC,OAAO,mBAAmB,SAAS,MAAM,eAAe,OAAO;CACjE;AACF;;;ACxDA,IAAa,qBAAb,MAAgC;;iCACH,IAAI,IAAiC;;CAEhE,SAAS,QAAmC;EAC1C,KAAK,QAAQ,IAAI,OAAO,SAAS,MAAM;CACzC;CAEA,IAAI,SAAkD;EACpD,OAAO,KAAK,QAAQ,IAAI,OAAO;CACjC;CAEA,SACE,SACA,SACA,SAC6B;EAC7B,MAAM,SAAS,KAAK,QAAQ,IAAI,OAAO;EACvC,IAAI,CAAC,QACH,OAAO,OAAO,IAAI,0CAA0C,QAAQ,EAAE;EAGxE,MAAM,gBAAgB,mBAAmB,MAAM,SAAS,OAAO;EAC/D,IAAI,cAAc,MAAM,GACtB,OAAO,OAAO,IAAI,cAAc,YAAY,CAAE;EAGhD,OAAO,OAAO,SAAS,cAAc,UAAU,GAAI,OAAO;CAC5D;AACF"}