@cullet/erp-core 1.0.2 → 1.0.3

package/src/core/policies/engines/index.ts

@@ -1,19 +1,19 @@
 export type { ComputePayload, ComputePayloadV1 } from "./compute-payload";
 export type {
-  ComputeEvaluator,
-  ComputeEvaluatorRegistration,
-  ComputeOutcome,
-  ComputeOutcomeData,
-  ComputeStatus,
-  VersionedComputeEngine,
+    ComputeEvaluator,
+    ComputeEvaluatorRegistration,
+    ComputeOutcome,
+    ComputeOutcomeData,
+    ComputeStatus,
+    VersionedComputeEngine,
 } from "./compute-types";
 export type {
-  ConditionEvaluationCause,
-  ConditionEvaluationOptions,
-  ConditionEvaluationReport,
-  ConditionEvaluationReportLevel,
-  ConditionEvaluationReportTag,
-  ConditionEvaluatorReporter,
+    ConditionEvaluationCause,
+    ConditionEvaluationOptions,
+    ConditionEvaluationReport,
+    ConditionEvaluationReportLevel,
+    ConditionEvaluationReportTag,
+    ConditionEvaluatorReporter,
 } from "./condition-evaluator-reporter";
 export { ComputeEngineRegistry } from "./compute-engine-registry";
 export { ComputeEvaluatorRegistry } from "./compute-evaluator-registry";
@@ -21,28 +21,28 @@ export { ComputeRegistry } from "./compute-registry";
 export { GateEngineRegistry } from "./gate-engine-registry";
 export type { GatePayload, GatePayloadV1 } from "./gate-payload";
 export type {
-  GateOutcome,
-  GateOutcomeData,
-  GateStatus,
-  GateTraceLeafSnapshot,
-  GateTraceNodeSnapshot,
-  GateViolationTrace,
-  PolicyContext,
-  PolicyViolation,
-  VersionedGateEngine,
+    GateOutcome,
+    GateOutcomeData,
+    GateStatus,
+    GateTraceLeafSnapshot,
+    GateTraceNodeSnapshot,
+    GateViolationTrace,
+    PolicyContext,
+    PolicyViolation,
+    VersionedGateEngine,
 } from "./gate-types";
 export {
-  ComputePayloadParsers,
-  ComputePayloadParserRegistry,
+    ComputePayloadParsers,
+    ComputePayloadParserRegistry,
 } from "./parse-compute-payload";
 export type { ComputePayloadParser } from "./parse-compute-payload";
 export {
-  GatePayloadParsers,
-  GatePayloadParserRegistry,
+    GatePayloadParsers,
+    GatePayloadParserRegistry,
 } from "./parse-gate-payload";
 export type { GatePayloadParser } from "./parse-gate-payload";
 export type {
-  ComputeDecisionTablePayload,
-  ComputeDecisionTableRule,
-  ComputeParamsPayload,
+    ComputeDecisionTablePayload,
+    ComputeDecisionTableRule,
+    ComputeParamsPayload,
 } from "./v1/compute";

package/src/core/policies/engines/parse-compute-payload.ts

@@ -5,67 +5,73 @@ import type { ComputePayload } from "./compute-payload";
 import { ComputePayloadSchemaV1 } from "./v1/compute/compute-payload.schema";
 
 export type ComputePayloadParser = (
-  payload: unknown,
+    payload: unknown,
 ) => ResultType<ComputePayload, string>;
 
 export class ComputePayloadParserRegistry {
-  private readonly parsers = new Map<number, ComputePayloadParser>();
+    private readonly parsers = new Map<number, ComputePayloadParser>();
 
-  register(payloadSchemaVersion: number, parser: ComputePayloadParser): void {
-    this.parsers.set(payloadSchemaVersion, parser);
-  }
+    register(payloadSchemaVersion: number, parser: ComputePayloadParser): void {
+        this.parsers.set(payloadSchemaVersion, parser);
+    }
+
+    get(payloadSchemaVersion: number): ComputePayloadParser | undefined {
+        return this.parsers.get(payloadSchemaVersion);
+    }
 
-  get(payloadSchemaVersion: number): ComputePayloadParser | undefined {
-    return this.parsers.get(payloadSchemaVersion);
-  }
+    parse(payloadSchemaVersion: number, payload: unknown) {
+        const parser = this.parsers.get(payloadSchemaVersion);
 
-  parse(payloadSchemaVersion: number, payload: unknown) {
-    const parser = this.parsers.get(payloadSchemaVersion);
+        if (parser === undefined) {
+            return Result.err(
+                `No compute payload parser registered for schema version "${payloadSchemaVersion}"`,
+            );
+        }
 
-    if (parser === undefined) {
-      return Result.err(
-        `No compute payload parser registered for schema version "${payloadSchemaVersion}"`,
-      );
+        return parser(payload);
     }
-
-    return parser(payload);
-  }
 }
 
 export class ComputePayloadParsers {
-  private static readonly registry = new ComputePayloadParserRegistry();
-  private static defaultsRegistered = false;
+    private static readonly registry = new ComputePayloadParserRegistry();
+    private static defaultsRegistered = false;
 
-  // Registers the built-in v1 parser lazily, the first time the default
-  // dispatcher is touched. Done here — rather than as a top-level module
-  // statement — so the package's `"sideEffects": false` flag stays honest and
-  // a tree-shaking bundler cannot drop the v1 registration and leave the
-  // compute engine unable to parse v1 payloads at runtime.
-  private static ensureDefaults(): void {
-    if (ComputePayloadParsers.defaultsRegistered) {
-      return;
+    // Registers the built-in v1 parser lazily, the first time the default
+    // dispatcher is touched. Done here — rather than as a top-level module
+    // statement — so the package's `"sideEffects": false` flag stays honest and
+    // a tree-shaking bundler cannot drop the v1 registration and leave the
+    // compute engine unable to parse v1 payloads at runtime.
+    private static ensureDefaults(): void {
+        if (ComputePayloadParsers.defaultsRegistered) {
+            return;
+        }
+        ComputePayloadParsers.defaultsRegistered = true;
+        ComputePayloadParsers.registry.register(
+            1,
+            ComputePayloadSchemaV1.parse,
+        );
     }
-    ComputePayloadParsers.defaultsRegistered = true;
-    ComputePayloadParsers.registry.register(1, ComputePayloadSchemaV1.parse);
-  }
 
-  static register(
-    payloadSchemaVersion: number,
-    parser: ComputePayloadParser,
-  ): void {
-    ComputePayloadParsers.ensureDefaults();
-    ComputePayloadParsers.registry.register(payloadSchemaVersion, parser);
-  }
+    static register(
+        payloadSchemaVersion: number,
+        parser: ComputePayloadParser,
+    ): void {
+        ComputePayloadParsers.ensureDefaults();
+        ComputePayloadParsers.registry.register(payloadSchemaVersion, parser);
+    }
 
-  static get(payloadSchemaVersion: number): ComputePayloadParser | undefined {
-    ComputePayloadParsers.ensureDefaults();
-    return ComputePayloadParsers.registry.get(payloadSchemaVersion);
-  }
+    static get(payloadSchemaVersion: number): ComputePayloadParser | undefined {
+        ComputePayloadParsers.ensureDefaults();
+        return ComputePayloadParsers.registry.get(payloadSchemaVersion);
+    }
 
-  static parse(payloadSchemaVersion: number, payload: unknown) {
-    ComputePayloadParsers.ensureDefaults();
-    return ComputePayloadParsers.registry.parse(payloadSchemaVersion, payload);
-  }
+    static parse(payloadSchemaVersion: number, payload: unknown) {
+        ComputePayloadParsers.ensureDefaults();
+        return ComputePayloadParsers.registry.parse(
+            payloadSchemaVersion,
+            payload,
+        );
+    }
 }
 
 export type { ComputePayload };

package/src/core/policies/engines/parse-gate-payload.ts

@@ -5,64 +5,64 @@ import type { GatePayload } from "./gate-payload";
 import { GatePayloadSchemaV1 } from "./v1/gate/gate-v1-payload.schema";
 
 export type GatePayloadParser = (
-  payload: unknown,
+    payload: unknown,
 ) => ResultType<GatePayload, string>;
 
 export class GatePayloadParserRegistry {
-  private readonly parsers = new Map<number, GatePayloadParser>();
+    private readonly parsers = new Map<number, GatePayloadParser>();
 
-  register(engineVersion: number, parser: GatePayloadParser): void {
-    this.parsers.set(engineVersion, parser);
-  }
+    register(engineVersion: number, parser: GatePayloadParser): void {
+        this.parsers.set(engineVersion, parser);
+    }
+
+    get(engineVersion: number): GatePayloadParser | undefined {
+        return this.parsers.get(engineVersion);
+    }
 
-  get(engineVersion: number): GatePayloadParser | undefined {
-    return this.parsers.get(engineVersion);
-  }
+    parse(engineVersion: number, payload: unknown) {
+        const parser = this.parsers.get(engineVersion);
 
-  parse(engineVersion: number, payload: unknown) {
-    const parser = this.parsers.get(engineVersion);
+        if (parser === undefined) {
+            return Result.err(
+                `No gate payload parser registered for engine version "${engineVersion}"`,
+            );
+        }
 
-    if (parser === undefined) {
-      return Result.err(
-        `No gate payload parser registered for engine version "${engineVersion}"`,
-      );
+        return parser(payload);
     }
-
-    return parser(payload);
-  }
 }
 
 export class GatePayloadParsers {
-  private static readonly registry = new GatePayloadParserRegistry();
-  private static defaultsRegistered = false;
+    private static readonly registry = new GatePayloadParserRegistry();
+    private static defaultsRegistered = false;
 
-  // Registers the built-in v1 parser lazily, the first time the default
-  // dispatcher is touched. Done here — rather than as a top-level module
-  // statement — so the package's `"sideEffects": false` flag stays honest and
-  // a tree-shaking bundler cannot drop the v1 registration and leave the gate
-  // engine unable to parse v1 payloads at runtime.
-  private static ensureDefaults(): void {
-    if (GatePayloadParsers.defaultsRegistered) {
-      return;
+    // Registers the built-in v1 parser lazily, the first time the default
+    // dispatcher is touched. Done here — rather than as a top-level module
+    // statement — so the package's `"sideEffects": false` flag stays honest and
+    // a tree-shaking bundler cannot drop the v1 registration and leave the gate
+    // engine unable to parse v1 payloads at runtime.
+    private static ensureDefaults(): void {
+        if (GatePayloadParsers.defaultsRegistered) {
+            return;
+        }
+        GatePayloadParsers.defaultsRegistered = true;
+        GatePayloadParsers.registry.register(1, GatePayloadSchemaV1.parse);
     }
-    GatePayloadParsers.defaultsRegistered = true;
-    GatePayloadParsers.registry.register(1, GatePayloadSchemaV1.parse);
-  }
 
-  static register(engineVersion: number, parser: GatePayloadParser): void {
-    GatePayloadParsers.ensureDefaults();
-    GatePayloadParsers.registry.register(engineVersion, parser);
-  }
+    static register(engineVersion: number, parser: GatePayloadParser): void {
+        GatePayloadParsers.ensureDefaults();
+        GatePayloadParsers.registry.register(engineVersion, parser);
+    }
 
-  static get(engineVersion: number): GatePayloadParser | undefined {
-    GatePayloadParsers.ensureDefaults();
-    return GatePayloadParsers.registry.get(engineVersion);
-  }
+    static get(engineVersion: number): GatePayloadParser | undefined {
+        GatePayloadParsers.ensureDefaults();
+        return GatePayloadParsers.registry.get(engineVersion);
+    }
 
-  static parse(engineVersion: number, payload: unknown) {
-    GatePayloadParsers.ensureDefaults();
-    return GatePayloadParsers.registry.parse(engineVersion, payload);
-  }
+    static parse(engineVersion: number, payload: unknown) {
+        GatePayloadParsers.ensureDefaults();
+        return GatePayloadParsers.registry.parse(engineVersion, payload);
+    }
 }
 
 export type { GatePayload };

package/src/core/policies/engines/v1/compute/compute-engine-v1.ts

@@ -4,9 +4,9 @@ import { Result } from "../../../../result/result";
 import type { ComputePayloadV1 as ComputePayload } from "./compute-payload.schema";
 import { DecisionTableResolverV1 } from "./resolve-decision-table-v1";
 import type {
-  ComputeEvaluator,
-  ComputeOutcome,
-  VersionedComputeEngine,
+    ComputeEvaluator,
+    ComputeOutcome,
+    VersionedComputeEngine,
 } from "../../compute-types";
 import type { PolicyContext } from "../../gate-types";
 
@@ -15,41 +15,43 @@ import type { PolicyContext } from "../../gate-types";
 const COMPUTE_ENGINE_VERSION = 1;
 
 export class ComputeEngineV1 implements VersionedComputeEngine {
-  readonly version = COMPUTE_ENGINE_VERSION;
-  private readonly coreConfig: CoreConfig;
-
-  constructor(params: { readonly coreConfig?: CoreConfig } = {}) {
-    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: ComputePayload,
-    context: PolicyContext,
-    evaluator: ComputeEvaluator,
-  ): Result<ComputeOutcome, string> {
-    if (payload.type === "params") {
-      return evaluator.evaluate(payload.data, context);
-    }
+    readonly version = COMPUTE_ENGINE_VERSION;
+    private readonly coreConfig: CoreConfig;
 
-    const resolvedResult = DecisionTableResolverV1.resolve(
-      payload,
-      context,
-      this.coreConfig.getConditionEvaluationOptions(COMPUTE_ENGINE_VERSION),
-    );
-    if (resolvedResult.isErr()) {
-      return Result.err(resolvedResult.errorOrNull()!);
+    constructor(params: { readonly coreConfig?: CoreConfig } = {}) {
+        this.coreConfig = params.coreConfig ?? coreConfig;
     }
 
-    return evaluator.evaluate(resolvedResult.getOrNull()!, context);
-  }
+    /**
+     * 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: ComputePayload,
+        context: PolicyContext,
+        evaluator: ComputeEvaluator,
+    ): Result<ComputeOutcome, string> {
+        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);
+    }
 }

package/src/core/policies/engines/v1/compute/compute-payload.schema.ts

@@ -8,68 +8,70 @@ import type { ConditionNode } from "../condition-types";
 // ─── Pattern 1: Params ──────────────────────────────────────────────────────
 
 export interface ComputeParamsPayload {
-  readonly type: "params";
-  readonly data: Readonly<Record<string, unknown>>;
+    readonly type: "params";
+    readonly data: Readonly<Record<string, unknown>>;
 }
 
 // ─── Pattern 2: Decision table ──────────────────────────────────────────────
 
 export interface ComputeDecisionTableRule<R = unknown> {
-  readonly conditions: ConditionNode;
-  readonly result: R;
+    readonly conditions: ConditionNode;
+    readonly result: R;
 }
 
 export interface ComputeDecisionTablePayload<R = unknown> {
-  readonly type: "decision-table";
-  readonly rules: readonly ComputeDecisionTableRule<R>[];
-  readonly default: R;
+    readonly type: "decision-table";
+    readonly rules: readonly ComputeDecisionTableRule<R>[];
+    readonly default: R;
 }
 
 // ─── Union ──────────────────────────────────────────────────────────────────
 
 export type ComputePayloadV1 =
-  | ComputeDecisionTablePayload<unknown>
-  | ComputeParamsPayload;
+    | ComputeDecisionTablePayload<unknown>
+    | ComputeParamsPayload;
 
 // ─── Zod schemas ────────────────────────────────────────────────────────────
 
 const computeDecisionTableRuleSchema = z.object({
-  conditions: conditionNodeSchema,
-  result: z.unknown(),
+    conditions: conditionNodeSchema,
+    result: z.unknown(),
 });
 
 export class ComputePayloadSchemaV1 {
-  static readonly 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: unknown): Result<ComputePayloadV1, string> {
-    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}`);
+    static readonly 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: unknown): Result<ComputePayloadV1, string> {
+        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 as ComputePayloadV1);
     }
-
-    return Result.ok(parsed.data as ComputePayloadV1);
-  }
 }
 
 export const computePayloadSchema = ComputePayloadSchemaV1.schema;

package/src/core/policies/engines/v1/compute/index.ts

@@ -1,12 +1,12 @@
 export { ComputeEngineV1 } from "./compute-engine-v1";
 export type {
-  ComputeDecisionTablePayload,
-  ComputeDecisionTableRule,
-  ComputeParamsPayload,
-  ComputePayloadV1,
+    ComputeDecisionTablePayload,
+    ComputeDecisionTableRule,
+    ComputeParamsPayload,
+    ComputePayloadV1,
 } from "./compute-payload.schema";
 export {
-  computePayloadSchema,
-  ComputePayloadSchemaV1,
+    computePayloadSchema,
+    ComputePayloadSchemaV1,
 } from "./compute-payload.schema";
 export { DecisionTableResolverV1 } from "./resolve-decision-table-v1";

package/src/core/policies/engines/v1/compute/resolve-decision-table-v1.ts

@@ -8,47 +8,49 @@ import type { ComputeDecisionTablePayload } from "./compute-payload.schema";
 const COMPUTE_CONDITION_EVAL_FAILED_TAG = "COMPUTE_CONDITION_EVAL_FAILED";
 
 export class DecisionTableResolverV1 {
-  constructor(
-    private readonly payload: ComputeDecisionTablePayload,
-    private readonly context: Record<string, unknown>,
-    private readonly conditionEvaluationOptions: ConditionEvaluationOptions,
-  ) {}
-
-  private wrapConditionEvaluationError(error: string): Result<unknown, string> {
-    return Result.err(`${COMPUTE_CONDITION_EVAL_FAILED_TAG}: ${error}`);
-  }
-
-  resolve(): Result<unknown, string> {
-    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()!,
+    constructor(
+        private readonly payload: ComputeDecisionTablePayload,
+        private readonly context: Record<string, unknown>,
+        private readonly conditionEvaluationOptions: ConditionEvaluationOptions,
+    ) {}
+
+    private wrapConditionEvaluationError(
+        error: string,
+    ): Result<unknown, string> {
+        return Result.err(`${COMPUTE_CONDITION_EVAL_FAILED_TAG}: ${error}`);
+    }
+
+    resolve(): Result<unknown, string> {
+        const evaluator = new ConditionEvaluatorV1(
+            this.context,
+            this.conditionEvaluationOptions,
         );
-      }
 
-      if (conditionResult.getOrNull()) {
-        return Result.ok(rule.result);
-      }
+        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);
     }
 
-    return Result.ok(this.payload.default);
-  }
-
-  static resolve(
-    payload: ComputeDecisionTablePayload,
-    context: Record<string, unknown>,
-    conditionEvaluationOptions: ConditionEvaluationOptions,
-  ): Result<unknown, string> {
-    return new DecisionTableResolverV1(
-      payload,
-      context,
-      conditionEvaluationOptions,
-    ).resolve();
-  }
+    static resolve(
+        payload: ComputeDecisionTablePayload,
+        context: Record<string, unknown>,
+        conditionEvaluationOptions: ConditionEvaluationOptions,
+    ): Result<unknown, string> {
+        return new DecisionTableResolverV1(
+            payload,
+            context,
+            conditionEvaluationOptions,
+        ).resolve();
+    }
 }