@cullet/erp-core 1.2.0 → 1.3.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"gate-engine-registry.cjs","names":["z","conditionNodeSchema","Result","Result","Result","Result","ConditionEvaluatorV1","coreConfig","Result","coreConfig","Result","GatePayloadSchemaV1","Result"],"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":";;;;AAmCA,MAAM,iCAAiCA,IAAAA,EAAE,OAAO;CAC5C,YAAYC,+BAAAA;CACZ,QAAQD,IAAAA,EAAE,QAAQ;AACtB,CAAC;AAED,IAAa,yBAAb,MAAa,uBAAuB;;gBACPA,IAAAA,EAAE,MAAM,CAC7BA,IAAAA,EACK,OAAO;GACJ,MAAMA,IAAAA,EAAE,QAAQ,gBAAgB;GAChC,OAAOA,IAAAA,EAAE,MAAM,8BAA8B,EAAE,IAAI,CAAC;GACpD,SAASA,IAAAA,EAAE,QAAQ;EACvB,CAAC,EACA,OAAO,GACZA,IAAAA,EACK,OAAO;GACJ,MAAMA,IAAAA,EAAE,QAAQ,QAAQ;GACxB,MAAMA,IAAAA,EAAE,OAAOA,IAAAA,EAAE,OAAO,GAAGA,IAAAA,EAAE,QAAQ,CAAC;EAC1C,CAAC,EACA,OAAO,CAChB,CAAC;;CAED,OAAO,MAAM,SAAoD;EAC7D,MAAM,SAAS,uBAAuB,OAAO,UAAU,OAAO;EAC9D,IAAI,CAAC,OAAO,SAAS;GACjB,MAAM,UAAU,OAAO,MAAM,OACxB,KAAK,UAAU;IACZ,MAAM,OAAO,MAAM,KAAK,KAAK,GAAG;IAChC,OAAO,KAAK,SAAS,IACf,GAAG,KAAK,IAAI,MAAM,YAClB,MAAM;GAChB,CAAC,EACA,KAAK,IAAI;GAEd,OAAOE,eAAAA,OAAO,IAAI,4BAA4B,SAAS;EAC3D;EAEA,OAAOA,eAAAA,OAAO,GAAG,OAAO,IAAwB;CACpD;AACJ;AAEoC,uBAAuB;;;AClE3D,IAAa,+BAAb,MAA0C;;iCACX,IAAI,IAAkC;;CAEjE,SAAS,sBAA8B,QAAoC;EACvE,KAAK,QAAQ,IAAI,sBAAsB,MAAM;CACjD;CAEA,IAAI,sBAAgE;EAChE,OAAO,KAAK,QAAQ,IAAI,oBAAoB;CAChD;CAEA,MAAM,sBAA8B,SAAkB;EAClD,MAAM,SAAS,KAAK,QAAQ,IAAI,oBAAoB;EAEpD,IAAI,WAAW,KAAA,GACX,OAAOC,eAAAA,OAAO,IACV,4DAA4D,qBAAqB,EACrF;EAGJ,OAAO,OAAO,OAAO;CACzB;AACJ;AAEA,IAAa,wBAAb,MAAa,sBAAsB;;kBACI,IAAI,6BAA6B;;;4BAChC;;CAOpC,OAAe,iBAAuB;EAClC,IAAI,sBAAsB,oBACtB;EAEJ,sBAAsB,qBAAqB;EAC3C,sBAAsB,SAAS,SAC3B,GACA,uBAAuB,KAC3B;CACJ;CAEA,OAAO,SACH,sBACA,QACI;EACJ,sBAAsB,eAAe;EACrC,sBAAsB,SAAS,SAAS,sBAAsB,MAAM;CACxE;CAEA,OAAO,IAAI,sBAAgE;EACvE,sBAAsB,eAAe;EACrC,OAAO,sBAAsB,SAAS,IAAI,oBAAoB;CAClE;CAEA,OAAO,MAAM,sBAA8B,SAAkB;EACzD,sBAAsB,eAAe;EACrC,OAAO,sBAAsB,SAAS,MAClC,sBACA,OACJ;CACJ;AACJ;;;AChEA,IAAa,wBAAb,MAAmC;;iCACJ,IAAI,IAAoC;;CAEnE,SAAS,QAAsC;EAC3C,KAAK,QAAQ,IAAI,OAAO,SAAS,MAAM;CAC3C;CAEA,IAAI,SAAqD;EACrD,OAAO,KAAK,QAAQ,IAAI,OAAO;CACnC;CAEA,SACI,SACA,QAO8B;EAC9B,MAAM,SAAS,KAAK,IAAI,OAAO;EAC/B,IAAI,WAAW,KAAA,GACX,OAAOC,eAAAA,OAAO,IACV,6CAA6C,QAAQ,EACzD;EAGJ,MAAM,YAAY,OAAO,WAAW,IAAI,OAAO,WAAW,OAAO;EACjE,IAAI,cAAc,KAAA,GACd,OAAOA,eAAAA,OAAO,IACV,mDAAmD,OAAO,UAAU,iBAAiB,QAAQ,EACjG;EAGJ,MAAM,sBAAsB,sBAAsB,MAC9C,OAAO,sBACP,OAAO,OACX;EACA,IAAI,oBAAoB,MAAM,GAC1B,OAAOA,eAAAA,OAAO,IAAI,oBAAoB,YAAY,CAAE;EAGxD,OAAO,OAAO,SACV,oBAAoB,UAAU,GAC9B,OAAO,SACP,SACJ;CACJ;AACJ;;;ACtDA,IAAa,2BAAb,MAAa,yBAAyB;;oCACJ,IAAI,IAA8B;;CAEhE,OAAe,cAAc,WAAmB,SAAyB;EACrE,OAAO,GAAG,UAAU,IAAI;CAC5B;CAEA,SAAS,cAAkD;EACvD,KAAK,WAAW,IACZ,yBAAyB,cACrB,aAAa,WACb,aAAa,OACjB,GACA,aAAa,SACjB;CACJ;CAEA,IAAI,WAAmB,SAA+C;EAClE,OAAO,KAAK,WAAW,IACnB,yBAAyB,cAAc,WAAW,OAAO,CAC7D;CACJ;AACJ;;;ACpBA,MAAM,oCAAoC;AAE1C,IAAa,0BAAb,MAAa,wBAAwB;CACjC,YACI,SACA,SACA,4BACF;EAHmB,KAAA,UAAA;EACA,KAAA,UAAA;EACA,KAAA,6BAAA;CAClB;CAEH,6BACI,OACuB;EACvB,OAAOC,eAAAA,OAAO,IAAI,GAAG,kCAAkC,IAAI,OAAO;CACtE;CAEA,UAAmC;EAC/B,MAAM,YAAY,IAAIC,+BAAAA,qBAClB,KAAK,SACL,KAAK,0BACT;EAEA,KAAK,MAAM,QAAQ,KAAK,QAAQ,OAAO;GACnC,MAAM,kBAAkB,UAAU,SAAS,KAAK,UAAU;GAC1D,IAAI,gBAAgB,MAAM,GACtB,OAAO,KAAK,6BACR,gBAAgB,YAAY,CAChC;GAGJ,IAAI,gBAAgB,UAAU,GAC1B,OAAOD,eAAAA,OAAO,GAAG,KAAK,MAAM;EAEpC;EAEA,OAAOA,eAAAA,OAAO,GAAG,KAAK,QAAQ,OAAO;CACzC;CAEA,OAAO,QACH,SACA,SACA,4BACuB;EACvB,OAAO,IAAI,wBACP,SACA,SACA,0BACJ,EAAE,QAAQ;CACd;AACJ;;;ACzCA,MAAM,yBAAyB;AAE/B,IAAa,kBAAb,MAA+D;CAI3D,YAAY,SAA+C,CAAC,GAAG;iBAH5C;EAIf,KAAK,aAAa,OAAO,cAAcE,+BAAAA;CAC3C;;;;;;;;;;;CAYA,SACI,SACA,SACA,WAC8B;EAC9B,IAAI,QAAQ,SAAS,UACjB,OAAO,UAAU,SAAS,QAAQ,MAAM,OAAO;EAGnD,MAAM,iBAAiB,wBAAwB,QAC3C,SACA,SACA,KAAK,WAAW,8BACZ,sBACJ,CACJ;EACA,IAAI,eAAe,MAAM,GACrB,OAAOC,eAAAA,OAAO,IAAI,eAAe,YAAY,CAAE;EAGnD,OAAO,UAAU,SAAS,eAAe,UAAU,GAAI,OAAO;CAClE;AACJ;;;ACtCA,IAAa,kBAAb,MAA6B;CAIzB,YAAY,SAAiC,CAAC,GAAG;iBAHtB,IAAI,sBAAsB;oBACvB,IAAI,yBAAyB;EAGvD,MAAM,qBAAqB,OAAO,cAAcC,+BAAAA;EAEhD,KAAK,QAAQ,SACT,IAAI,gBAAgB,EAChB,YAAY,mBAChB,CAAC,CACL;CACJ;CAEA,SAAS,cAAkD;EACvD,KAAK,WAAW,SAAS,YAAY;CACzC;CAEA,eAAe,QAAsC;EACjD,KAAK,QAAQ,SAAS,MAAM;CAChC;CAEA,UAAU,SAAqD;EAC3D,OAAO,KAAK,QAAQ,IAAI,OAAO;CACnC;CAEA,aACI,WACA,SAC4B;EAC5B,OAAO,KAAK,WAAW,IAAI,WAAW,OAAO;CACjD;CAEA,SACI,WACA,sBACA,sBACA,SACA,SAC8B;EAC9B,OAAO,KAAK,QAAQ,SAAS,sBAAsB;GAC/C;GACA;GACA;GACA;GACA,YAAY,KAAK;EACrB,CAAC;CACL;AACJ;;;ACxDA,IAAa,4BAAb,MAAuC;;iCACR,IAAI,IAA+B;;CAE9D,SAAS,eAAuB,QAAiC;EAC7D,KAAK,QAAQ,IAAI,eAAe,MAAM;CAC1C;CAEA,IAAI,eAAsD;EACtD,OAAO,KAAK,QAAQ,IAAI,aAAa;CACzC;CAEA,MAAM,eAAuB,SAAkB;EAC3C,MAAM,SAAS,KAAK,QAAQ,IAAI,aAAa;EAE7C,IAAI,WAAW,KAAA,GACX,OAAOC,eAAAA,OAAO,IACV,yDAAyD,cAAc,EAC3E;EAGJ,OAAO,OAAO,OAAO;CACzB;AACJ;AAEA,IAAa,qBAAb,MAAa,mBAAmB;;kBACO,IAAI,0BAA0B;;;4BAC7B;;CAOpC,OAAe,iBAAuB;EAClC,IAAI,mBAAmB,oBACnB;EAEJ,mBAAmB,qBAAqB;EACxC,mBAAmB,SAAS,SAAS,GAAGC,+BAAAA,oBAAoB,KAAK;CACrE;CAEA,OAAO,SAAS,eAAuB,QAAiC;EACpE,mBAAmB,eAAe;EAClC,mBAAmB,SAAS,SAAS,eAAe,MAAM;CAC9D;CAEA,OAAO,IAAI,eAAsD;EAC7D,mBAAmB,eAAe;EAClC,OAAO,mBAAmB,SAAS,IAAI,aAAa;CACxD;CAEA,OAAO,MAAM,eAAuB,SAAkB;EAClD,mBAAmB,eAAe;EAClC,OAAO,mBAAmB,SAAS,MAAM,eAAe,OAAO;CACnE;AACJ;;;ACxDA,IAAa,qBAAb,MAAgC;;iCACD,IAAI,IAAiC;;CAEhE,SAAS,QAAmC;EACxC,KAAK,QAAQ,IAAI,OAAO,SAAS,MAAM;CAC3C;CAEA,IAAI,SAAkD;EAClD,OAAO,KAAK,QAAQ,IAAI,OAAO;CACnC;CAEA,SACI,SACA,SACA,SAC2B;EAC3B,MAAM,SAAS,KAAK,QAAQ,IAAI,OAAO;EACvC,IAAI,CAAC,QACD,OAAOC,eAAAA,OAAO,IACV,0CAA0C,QAAQ,EACtD;EAGJ,MAAM,gBAAgB,mBAAmB,MAAM,SAAS,OAAO;EAC/D,IAAI,cAAc,MAAM,GACpB,OAAOA,eAAAA,OAAO,IAAI,cAAc,YAAY,CAAE;EAGlD,OAAO,OAAO,SAAS,cAAc,UAAU,GAAI,OAAO;CAC9D;AACJ"}

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

@@ -0,0 +1,81 @@
+import { a as Result, n as Outcome } from "./outcome.cjs";
+import { c as PolicyViolation, l as VersionedGateEngine, m as CoreConfig, p as ConditionNode, s as PolicyContext, t as GateOutcome } from "./gate-types.cjs";
+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.cts.map

package/dist/gate-types.d.cts

@@ -0,0 +1,171 @@
+import { a as Result, n as Outcome } from "./outcome.cjs";
+
+//#region src/core/policies/engines/condition-evaluator-reporter.d.ts
+interface ConditionEvaluationCause {
+  readonly name: string;
+  readonly message: string;
+}
+type ConditionEvaluationReportLevel = "warn" | "error";
+type ConditionEvaluationReportTag = "MISSING_CONTEXT_FIELD" | "NULLISH_NUMERIC_OPERAND_NOT_ALLOWED" | "NULLISH_DATE_OPERAND_NOT_ALLOWED" | "INVALID_DATE_OPERAND" | "INVALID_NUMERIC_OPERAND" | "INVALID_SET_OPERAND" | "CONDITION_EVAL_THREW";
+interface ConditionEvaluationReport {
+  readonly occurredAt: Date;
+  readonly level: ConditionEvaluationReportLevel;
+  readonly tag: ConditionEvaluationReportTag;
+  readonly message: string;
+  readonly engineVersion: number;
+  readonly details: Readonly<Record<string, unknown>>;
+}
+interface ConditionEvaluatorReporter {
+  warn(report: ConditionEvaluationReport): void;
+  error(report: ConditionEvaluationReport): void;
+}
+type ConditionEvaluationOptions = {
+  readonly reporter: ConditionEvaluatorReporter;
+  readonly engineVersion: number;
+};
+//#endregion
+//#region src/core/policies/policy-ids.d.ts
+type Brand<TValue, TBrand extends string> = TValue & {
+  readonly __brand: TBrand;
+};
+type PolicyDefinitionId = Brand<string, "PolicyDefinitionId">;
+type PolicyDecisionId = Brand<string, "PolicyDecisionId">;
+type TenantId = Brand<string, "TenantId">;
+type SchoolId = Brand<string, "SchoolId">;
+declare function asPolicyDefinitionId(value: string): PolicyDefinitionId;
+declare function asPolicyDecisionId(value: string): PolicyDecisionId;
+declare function asTenantId(value: string): TenantId;
+declare function asSchoolId(value: string): SchoolId;
+//#endregion
+//#region src/core/config/policy-reporter.d.ts
+type ConditionEvalEvent = ConditionEvaluationReport & {
+  readonly kind: "condition-eval";
+};
+interface PolicyResolutionEvent {
+  readonly kind: "policy-resolution";
+  readonly level: "info";
+  readonly policyKey: string;
+  readonly definitionId: PolicyDefinitionId;
+  readonly policyVersion: string;
+  readonly engineKind: "GATE" | "COMPUTE";
+  readonly engineVersion: number;
+  readonly occurredAt: Date;
+}
+interface PolicyEvaluationFailedEvent {
+  readonly kind: "policy-evaluation-failed";
+  readonly level: "error";
+  readonly policyKey: string | undefined;
+  readonly errorKind: string;
+  readonly message: string;
+  readonly cause: string;
+  readonly occurredAt: Date;
+}
+interface PolicyEvaluationCompletedEvent {
+  readonly kind: "policy-evaluation-completed";
+  readonly level: "info";
+  readonly policyKey: string;
+  readonly decisionId: PolicyDecisionId;
+  readonly engineKind: "GATE" | "COMPUTE";
+  readonly occurredAt: Date;
+}
+type PolicyEvent = ConditionEvalEvent | PolicyResolutionEvent | PolicyEvaluationFailedEvent | PolicyEvaluationCompletedEvent;
+interface PolicyReporter {
+  report(event: PolicyEvent): void;
+}
+//#endregion
+//#region src/core/config/core-config.d.ts
+interface CoreObservabilityConfig {
+  readonly reporter?: PolicyReporter;
+}
+interface CoreConfigOptions {
+  readonly observability?: CoreObservabilityConfig;
+}
+/**
+ * Centraliza a configuracao pura do core sem depender de implementacoes
+ * concretas de logging, tracing ou report.
+ */
+declare class CoreConfig {
+  #private;
+  constructor(options?: CoreConfigOptions);
+  configure(options: CoreConfigOptions): this;
+  reset(): this;
+  getPolicyReporter(): PolicyReporter;
+  getConditionEvaluationOptions(engineVersion: number): ConditionEvaluationOptions;
+}
+//#endregion
+//#region src/core/policies/engines/v1/condition-types.d.ts
+type ConditionOp = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "notIn" | "isNull" | "isNotNull";
+interface ConditionLeafNode {
+  readonly field: string;
+  readonly op: ConditionOp;
+  readonly value: unknown;
+  readonly allowNull?: true;
+}
+interface ConditionAndNode {
+  readonly and: readonly ConditionNode[];
+}
+interface ConditionOrNode {
+  readonly or: readonly ConditionNode[];
+}
+interface ConditionNotNode {
+  readonly not: ConditionNode;
+}
+type ConditionNode = ConditionLeafNode | ConditionAndNode | ConditionOrNode | ConditionNotNode;
+//#endregion
+//#region src/core/policies/engines/v1/gate/gate-types-v1.d.ts
+type GatePayloadV1 = {
+  readonly condition: ConditionNode;
+} | {
+  readonly allowIf: ConditionNode;
+  readonly defaultOutcome: "ALLOW" | "DENY";
+};
+//#endregion
+//#region src/core/policies/engines/gate-payload.d.ts
+type GatePayload = GatePayloadV1;
+//#endregion
+//#region src/core/policies/engines/gate-types.d.ts
+type PolicyContext = Record<string, unknown>;
+interface GateTraceLeafSnapshot {
+  readonly kind: "LEAF";
+  readonly field: string;
+  readonly op: string;
+  readonly allowNull?: true;
+}
+type GateTraceNodeSnapshot = GateTraceLeafSnapshot | {
+  readonly kind: "AND" | "OR";
+  readonly childCount: number;
+} | {
+  readonly kind: "NOT";
+};
+interface GateViolationTrace {
+  readonly conditionPath: string;
+  readonly decisiveNode: GateTraceNodeSnapshot;
+  readonly lastEvaluatedLeaf: GateTraceLeafSnapshot;
+  readonly lastEvaluatedLeafPath: string;
+  readonly lastEvaluatedLeafResult: boolean;
+  readonly field: string;
+  readonly op: string;
+}
+interface PolicyViolation {
+  readonly code: string;
+  readonly message: string;
+  readonly trace?: GateViolationTrace;
+}
+type GateStatus = "ALLOW" | "DENY";
+interface GateOutcomeData {
+  readonly violations: readonly PolicyViolation[];
+}
+/** Semantic outcome of a GATE policy evaluation. */
+type GateOutcome = Outcome<GateStatus, GateOutcomeData>;
+/**
+ * Contract every versioned gate engine must satisfy.
+ * Receives an already-parsed `GatePayload`; parsing from raw `unknown` is
+ * the registry's responsibility via `parseGatePayload`.
+ */
+interface VersionedGateEngine {
+  readonly version: number;
+  evaluate(payload: GatePayload, context: PolicyContext): Result<GateOutcome, string>;
+}
+//#endregion
+export { ConditionEvaluationReportTag as A, asPolicyDefinitionId as C, ConditionEvaluationOptions as D, ConditionEvaluationCause as E, ConditionEvaluationReport as O, asPolicyDecisionId as S, asTenantId as T, PolicyReporter as _, GateTraceNodeSnapshot as a, SchoolId as b, PolicyViolation as c, GatePayloadV1 as d, ConditionLeafNode as f, CoreObservabilityConfig as g, CoreConfigOptions as h, GateTraceLeafSnapshot as i, ConditionEvaluatorReporter as j, ConditionEvaluationReportLevel as k, VersionedGateEngine as l, CoreConfig as m, GateOutcomeData as n, GateViolationTrace as o, ConditionNode as p, GateStatus as r, PolicyContext as s, GateOutcome as t, GatePayload as u, PolicyDecisionId as v, asSchoolId as w, TenantId as x, PolicyDefinitionId as y };
+//# sourceMappingURL=gate-types.d.cts.map