@cullet/erp-core 1.2.0 → 1.4.0

package/dist/invalid-state-transition-exception.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalid-state-transition-exception.cjs","names":["DomainException","DomainException","DomainException"],"sources":["../src/core/exceptions/business-rule-violation-exception.ts","../src/core/exceptions/entity-not-found-exception.ts","../src/core/exceptions/invalid-state-transition-exception.ts"],"sourcesContent":["import { DomainException } from \"./domain-exception.js\";\n\nclass BusinessRuleViolationException extends DomainException {\n    constructor(\n        public readonly rule: string,\n        message: string,\n    ) {\n        super(message);\n    }\n}\n\nexport { BusinessRuleViolationException };\n","import { DomainException } from \"./domain-exception.js\";\n\nclass EntityNotFoundException extends DomainException {\n    constructor(\n        public readonly entityName: string,\n        public readonly identifier: string,\n    ) {\n        super(`${entityName} with identifier ${identifier} was not found.`);\n    }\n}\n\nexport { EntityNotFoundException };\n","import { DomainException } from \"./domain-exception.js\";\n\nclass InvalidStateTransitionException<\n    TState extends string = string,\n> extends DomainException {\n    constructor(\n        public readonly from: TState,\n        public readonly to: TState,\n        message: string,\n    ) {\n        super(message);\n    }\n}\n\nexport { InvalidStateTransitionException };\n"],"mappings":";;AAEA,IAAM,iCAAN,cAA6CA,yBAAAA,gBAAgB;CACzD,YACI,MACA,SACF;EACE,MAAM,OAAO;EAHG,KAAA,OAAA;CAIpB;AACJ;;;ACPA,IAAM,0BAAN,cAAsCC,yBAAAA,gBAAgB;CAClD,YACI,YACA,YACF;EACE,MAAM,GAAG,WAAW,mBAAmB,WAAW,gBAAgB;EAHlD,KAAA,aAAA;EACA,KAAA,aAAA;CAGpB;AACJ;;;ACPA,IAAM,kCAAN,cAEUC,yBAAAA,gBAAgB;CACtB,YACI,MACA,IACA,SACF;EACE,MAAM,OAAO;EAJG,KAAA,OAAA;EACA,KAAA,KAAA;CAIpB;AACJ"}

package/dist/invariant-violation-exception.cjs

@@ -0,0 +1,16 @@
+const require_domain_exception = require("./domain-exception.cjs");
+//#region src/core/exceptions/invariant-violation-exception.ts
+var InvariantViolationException = class extends require_domain_exception.DomainException {
+	constructor(message) {
+		super(message);
+	}
+};
+//#endregion
+Object.defineProperty(exports, "InvariantViolationException", {
+	enumerable: true,
+	get: function() {
+		return InvariantViolationException;
+	}
+});
+
+//# sourceMappingURL=invariant-violation-exception.cjs.map

package/dist/invariant-violation-exception.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"invariant-violation-exception.cjs","names":["DomainException"],"sources":["../src/core/exceptions/invariant-violation-exception.ts"],"sourcesContent":["import { DomainException } from \"./domain-exception.js\";\n\nclass InvariantViolationException extends DomainException {\n    constructor(message: string) {\n        super(message);\n    }\n}\n\nexport { InvariantViolationException };\n"],"mappings":";;AAEA,IAAM,8BAAN,cAA0CA,yBAAAA,gBAAgB;CACtD,YAAY,SAAiB;EACzB,MAAM,OAAO;CACjB;AACJ"}

package/dist/not-found-error.cjs

@@ -0,0 +1,65 @@
+const require_app_error = require("./app-error.cjs");
+//#region src/core/errors/business-rule-violation-error.ts
+var BusinessRuleViolationError = class extends require_app_error.AppError {
+	constructor(rule, message, detail, options) {
+		const baseMetadata = detail ? {
+			rule,
+			detail
+		} : { rule };
+		const mergedMetadata = options?.metadata ? {
+			...baseMetadata,
+			...options.metadata
+		} : baseMetadata;
+		super(message, require_app_error.ErrorCodes.businessRuleViolation, {
+			...options,
+			metadata: mergedMetadata
+		});
+	}
+};
+//#endregion
+//#region src/core/errors/not-found-error.ts
+/**
+* Raised when a requested resource does not exist. Maps naturally onto an HTTP
+* 404 at the edge, but stays transport-agnostic here.
+*
+* The `resource` name builds the message (`"<resource> not found"`) and, with
+* the optional lookup `criteria`, lands in the metadata so logs show *what* was
+* searched for without the caller having to restate it in the message.
+*/
+var NotFoundError = class extends require_app_error.AppError {
+	/**
+	* @param resource - Human-readable name of the missing resource (e.g. `"Order"`).
+	* @param criteria - Optional lookup keys used in the search; recorded in
+	*   metadata to aid debugging. Avoid putting sensitive values here.
+	* @param options - Optional cause, correlation ids, and extra metadata.
+	*/
+	constructor(resource, criteria, options) {
+		const baseMetadata = criteria ? {
+			resource,
+			criteria
+		} : { resource };
+		const mergedMetadata = options?.metadata ? {
+			...baseMetadata,
+			...options.metadata
+		} : baseMetadata;
+		super(`${resource} not found`, require_app_error.ErrorCodes.notFound, {
+			...options,
+			metadata: mergedMetadata
+		});
+	}
+};
+//#endregion
+Object.defineProperty(exports, "BusinessRuleViolationError", {
+	enumerable: true,
+	get: function() {
+		return BusinessRuleViolationError;
+	}
+});
+Object.defineProperty(exports, "NotFoundError", {
+	enumerable: true,
+	get: function() {
+		return NotFoundError;
+	}
+});
+
+//# sourceMappingURL=not-found-error.cjs.map

package/dist/not-found-error.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"not-found-error.cjs","names":["AppError","ErrorCodes","AppError","ErrorCodes"],"sources":["../src/core/errors/business-rule-violation-error.ts","../src/core/errors/not-found-error.ts"],"sourcesContent":["import { AppError } from \"./app-error.js\";\nimport { ErrorCodes } from \"./error-codes.js\";\nimport type { AppErrorOptions } from \"./types.js\";\n\n// ─────────────────────────────────────────────────────────────────────────────\n// BusinessRuleViolationError\n// ─────────────────────────────────────────────────────────────────────────────\n\nclass BusinessRuleViolationError extends AppError {\n    constructor(\n        rule: string,\n        message: string,\n        detail?: Record<string, unknown>,\n        options?: AppErrorOptions,\n    ) {\n        const baseMetadata = detail ? { rule, detail } : { rule };\n        const mergedMetadata = options?.metadata\n            ? { ...baseMetadata, ...options.metadata }\n            : baseMetadata;\n\n        super(message, ErrorCodes.businessRuleViolation, {\n            ...options,\n            metadata: mergedMetadata,\n        });\n    }\n}\n\nexport { BusinessRuleViolationError };\n","import { AppError } from \"./app-error.js\";\nimport { ErrorCodes } from \"./error-codes.js\";\nimport type { AppErrorOptions } from \"./types.js\";\n\n// ─────────────────────────────────────────────────────────────────────────────\n// NotFoundError\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Raised when a requested resource does not exist. Maps naturally onto an HTTP\n * 404 at the edge, but stays transport-agnostic here.\n *\n * The `resource` name builds the message (`\"<resource> not found\"`) and, with\n * the optional lookup `criteria`, lands in the metadata so logs show *what* was\n * searched for without the caller having to restate it in the message.\n */\nclass NotFoundError extends AppError {\n    /**\n     * @param resource - Human-readable name of the missing resource (e.g. `\"Order\"`).\n     * @param criteria - Optional lookup keys used in the search; recorded in\n     *   metadata to aid debugging. Avoid putting sensitive values here.\n     * @param options - Optional cause, correlation ids, and extra metadata.\n     */\n    constructor(\n        resource: string,\n        criteria?: Record<string, unknown>,\n        options?: AppErrorOptions,\n    ) {\n        const baseMetadata = criteria ? { resource, criteria } : { resource };\n        const mergedMetadata = options?.metadata\n            ? { ...baseMetadata, ...options.metadata }\n            : baseMetadata;\n\n        super(`${resource} not found`, ErrorCodes.notFound, {\n            ...options,\n            metadata: mergedMetadata,\n        });\n    }\n}\n\nexport { NotFoundError };\n"],"mappings":";;AAQA,IAAM,6BAAN,cAAyCA,kBAAAA,SAAS;CAC9C,YACI,MACA,SACA,QACA,SACF;EACE,MAAM,eAAe,SAAS;GAAE;GAAM;EAAO,IAAI,EAAE,KAAK;EACxD,MAAM,iBAAiB,SAAS,WAC1B;GAAE,GAAG;GAAc,GAAG,QAAQ;EAAS,IACvC;EAEN,MAAM,SAASC,kBAAAA,WAAW,uBAAuB;GAC7C,GAAG;GACH,UAAU;EACd,CAAC;CACL;AACJ;;;;;;;;;;;ACTA,IAAM,gBAAN,cAA4BC,kBAAAA,SAAS;;;;;;;CAOjC,YACI,UACA,UACA,SACF;EACE,MAAM,eAAe,WAAW;GAAE;GAAU;EAAS,IAAI,EAAE,SAAS;EACpE,MAAM,iBAAiB,SAAS,WAC1B;GAAE,GAAG;GAAc,GAAG,QAAQ;EAAS,IACvC;EAEN,MAAM,GAAG,SAAS,aAAaC,kBAAAA,WAAW,UAAU;GAChD,GAAG;GACH,UAAU;EACd,CAAC;CACL;AACJ"}

package/dist/not-found-error.js

@@ -1,4 +1,4 @@
-import { i as ErrorCodes, n as AppError } from "./unexpected-error.js";
+import { r as ErrorCodes, t as AppError } from "./app-error.js";
 //#region src/core/errors/business-rule-violation-error.ts
 var BusinessRuleViolationError = class extends AppError {
 	constructor(rule, message, detail, options) {

package/dist/outcome.cjs

@@ -0,0 +1,97 @@
+const require_invariant_violation_exception = require("./invariant-violation-exception.cjs");
+//#region src/core/result/outcome.ts
+/**
+* Outcome — Business decision abstraction.
+*
+* Represents the semantic result of a domain decision, policy evaluation,
+* or business rule. NOT for technical success/failure — use Result for that.
+*
+* Mental model:
+*   "What was the business decision?"
+*   NOT "Did the operation succeed?"
+*
+* The status axis represents valid business outcomes (APPROVED, REJECTED,
+* ALLOW, DENY, NO_OP, etc.), never technical Ok/Err.
+*
+* @typeParam S - Union of valid status literals for this outcome
+* @typeParam D - Shape of the decision data carried by this outcome
+*/
+var Outcome = class Outcome {
+	constructor(status, data, reason, metadata) {
+		this.status = status;
+		this.data = data;
+		this.reason = reason;
+		this.metadata = metadata;
+		Object.freeze(this);
+	}
+	static of(status, data, reason, metadata) {
+		return new Outcome(status, data, reason, Object.freeze({ ...metadata }));
+	}
+	static approved(data, reason) {
+		return new Outcome("APPROVED", data, reason, Object.freeze({}));
+	}
+	static rejected(data, reason) {
+		return new Outcome("REJECTED", data, reason, Object.freeze({}));
+	}
+	static noOp(data, reason) {
+		return new Outcome("NO_OP", data, reason, Object.freeze({}));
+	}
+	static deferred(data, reason) {
+		return new Outcome("DEFERRED", data, reason, Object.freeze({}));
+	}
+	static requiresReview(data, reason) {
+		return new Outcome("REQUIRES_REVIEW", data, reason, Object.freeze({}));
+	}
+	/**
+	* Narrows this Outcome to a specific status.
+	*
+	* @example
+	* if (outcome.is('DENY')) {
+	*   outcome.data.violations // TS knows status is 'DENY'
+	* }
+	*/
+	is(status) {
+		return this.status === status;
+	}
+	/**
+	* Exhaustive pattern match over all possible statuses.
+	* TypeScript enforces that every status has a handler.
+	*
+	* @example
+	* outcome.match({
+	*   ALLOW: (o) => handleAllow(o.data),
+	*   DENY:  (o) => handleDeny(o.data.violations),
+	* })
+	*/
+	match(handlers) {
+		const handler = handlers[this.status];
+		if (typeof handler !== "function") {
+			const availableStatuses = Object.keys(handlers);
+			throw new require_invariant_violation_exception.InvariantViolationException(`Outcome.match is missing a handler for runtime status "${this.status}". Available handlers: ${availableStatuses.join(", ") || "(none)"}`);
+		}
+		return handler(this);
+	}
+	withMetadata(extra) {
+		return new Outcome(this.status, this.data, this.reason, Object.freeze({
+			...this.metadata,
+			...extra
+		}));
+	}
+	withReason(reason) {
+		return new Outcome(this.status, this.data, reason, this.metadata);
+	}
+	toString() {
+		const parts = [this.status];
+		if (this.reason) parts.push(`reason="${this.reason}"`);
+		return `Outcome(${parts.join(", ")})`;
+	}
+};
+//#endregion
+Object.defineProperty(exports, "Outcome", {
+	enumerable: true,
+	get: function() {
+		return Outcome;
+	}
+});
+
+//# sourceMappingURL=outcome.cjs.map

package/dist/outcome.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"outcome.cjs","names":["InvariantViolationException"],"sources":["../src/core/result/outcome.ts"],"sourcesContent":["// core/domain/outcome.ts\n\nimport { InvariantViolationException } from \"../exceptions/invariant-violation-exception.js\";\n\n/**\n * Outcome — Business decision abstraction.\n *\n * Represents the semantic result of a domain decision, policy evaluation,\n * or business rule. NOT for technical success/failure — use Result for that.\n *\n * Mental model:\n *   \"What was the business decision?\"\n *   NOT \"Did the operation succeed?\"\n *\n * The status axis represents valid business outcomes (APPROVED, REJECTED,\n * ALLOW, DENY, NO_OP, etc.), never technical Ok/Err.\n *\n * @typeParam S - Union of valid status literals for this outcome\n * @typeParam D - Shape of the decision data carried by this outcome\n */\nexport class Outcome<S extends string, D = undefined> {\n    readonly status: S;\n    readonly data: D;\n    readonly reason: string | undefined;\n    readonly metadata: Readonly<Record<string, unknown>>;\n\n    private constructor(\n        status: S,\n        data: D,\n        reason: string | undefined,\n        metadata: Readonly<Record<string, unknown>>,\n    ) {\n        this.status = status;\n        this.data = data;\n        this.reason = reason;\n        this.metadata = metadata;\n        Object.freeze(this);\n    }\n\n    // ─── Generic factory ────────────────────────────────────────────────\n\n    static of<S extends string, D = undefined>(\n        status: S,\n        data: D,\n        reason?: string,\n        metadata?: Record<string, unknown>,\n    ): Outcome<S, D> {\n        return new Outcome(\n            status,\n            data,\n            reason,\n            Object.freeze({ ...metadata }),\n        );\n    }\n\n    // ─── Convenience factories for common business statuses ─────────────\n\n    static approved<D = undefined>(\n        data: D,\n        reason?: string,\n    ): Outcome<\"APPROVED\", D> {\n        return new Outcome(\"APPROVED\", data, reason, Object.freeze({}));\n    }\n\n    static rejected<D = undefined>(\n        data: D,\n        reason: string,\n    ): Outcome<\"REJECTED\", D> {\n        return new Outcome(\"REJECTED\", data, reason, Object.freeze({}));\n    }\n\n    static noOp<D = undefined>(data: D, reason?: string): Outcome<\"NO_OP\", D> {\n        return new Outcome(\"NO_OP\", data, reason, Object.freeze({}));\n    }\n\n    static deferred<D = undefined>(\n        data: D,\n        reason: string,\n    ): Outcome<\"DEFERRED\", D> {\n        return new Outcome(\"DEFERRED\", data, reason, Object.freeze({}));\n    }\n\n    static requiresReview<D = undefined>(\n        data: D,\n        reason: string,\n    ): Outcome<\"REQUIRES_REVIEW\", D> {\n        return new Outcome(\"REQUIRES_REVIEW\", data, reason, Object.freeze({}));\n    }\n\n    // ─── Type narrowing ────────────────────────────────────────────────\n\n    /**\n     * Narrows this Outcome to a specific status.\n     *\n     * @example\n     * if (outcome.is('DENY')) {\n     *   outcome.data.violations // TS knows status is 'DENY'\n     * }\n     */\n    is<T extends S>(status: T): this is Outcome<T, D> {\n        return (this.status as string) === status;\n    }\n\n    // ─── Exhaustive match ──────────────────────────────────────────────\n\n    /**\n     * Exhaustive pattern match over all possible statuses.\n     * TypeScript enforces that every status has a handler.\n     *\n     * @example\n     * outcome.match({\n     *   ALLOW: (o) => handleAllow(o.data),\n     *   DENY:  (o) => handleDeny(o.data.violations),\n     * })\n     */\n    match<THandlers extends { [K in S]: (outcome: Outcome<K, D>) => unknown }>(\n        handlers: THandlers,\n    ): ReturnType<THandlers[S]> {\n        const handler = (\n            handlers as Partial<Record<string, (o: unknown) => unknown>>\n        )[this.status];\n\n        if (typeof handler !== \"function\") {\n            const availableStatuses = Object.keys(handlers);\n            throw new InvariantViolationException(\n                `Outcome.match is missing a handler for runtime status \"${this.status}\". Available handlers: ${availableStatuses.join(\", \") || \"(none)\"}`,\n            );\n        }\n\n        return handler(this) as ReturnType<THandlers[S]>;\n    }\n\n    // ─── Derived copies ────────────────────────────────────────────────\n\n    withMetadata(extra: Record<string, unknown>): Outcome<S, D> {\n        return new Outcome(\n            this.status,\n            this.data,\n            this.reason,\n            Object.freeze({ ...this.metadata, ...extra }),\n        );\n    }\n\n    withReason(reason: string): Outcome<S, D> {\n        return new Outcome(this.status, this.data, reason, this.metadata);\n    }\n\n    // ─── Debug ─────────────────────────────────────────────────────────\n\n    toString(): string {\n        const parts: string[] = [this.status];\n        if (this.reason) parts.push(`reason=\"${this.reason}\"`);\n        return `Outcome(${parts.join(\", \")})`;\n    }\n}\n\n/** Common business outcome statuses. Extend per domain as needed. */\nexport type CommonOutcomeStatus =\n    | \"APPROVED\"\n    | \"REJECTED\"\n    | \"NO_OP\"\n    | \"DEFERRED\"\n    | \"REQUIRES_REVIEW\";\n"],"mappings":";;;;;;;;;;;;;;;;;;AAoBA,IAAa,UAAb,MAAa,QAAyC;CAMlD,YACI,QACA,MACA,QACA,UACF;EACE,KAAK,SAAS;EACd,KAAK,OAAO;EACZ,KAAK,SAAS;EACd,KAAK,WAAW;EAChB,OAAO,OAAO,IAAI;CACtB;CAIA,OAAO,GACH,QACA,MACA,QACA,UACa;EACb,OAAO,IAAI,QACP,QACA,MACA,QACA,OAAO,OAAO,EAAE,GAAG,SAAS,CAAC,CACjC;CACJ;CAIA,OAAO,SACH,MACA,QACsB;EACtB,OAAO,IAAI,QAAQ,YAAY,MAAM,QAAQ,OAAO,OAAO,CAAC,CAAC,CAAC;CAClE;CAEA,OAAO,SACH,MACA,QACsB;EACtB,OAAO,IAAI,QAAQ,YAAY,MAAM,QAAQ,OAAO,OAAO,CAAC,CAAC,CAAC;CAClE;CAEA,OAAO,KAAoB,MAAS,QAAsC;EACtE,OAAO,IAAI,QAAQ,SAAS,MAAM,QAAQ,OAAO,OAAO,CAAC,CAAC,CAAC;CAC/D;CAEA,OAAO,SACH,MACA,QACsB;EACtB,OAAO,IAAI,QAAQ,YAAY,MAAM,QAAQ,OAAO,OAAO,CAAC,CAAC,CAAC;CAClE;CAEA,OAAO,eACH,MACA,QAC6B;EAC7B,OAAO,IAAI,QAAQ,mBAAmB,MAAM,QAAQ,OAAO,OAAO,CAAC,CAAC,CAAC;CACzE;;;;;;;;;CAYA,GAAgB,QAAkC;EAC9C,OAAQ,KAAK,WAAsB;CACvC;;;;;;;;;;;CAcA,MACI,UACwB;EACxB,MAAM,UACF,SACF,KAAK;EAEP,IAAI,OAAO,YAAY,YAAY;GAC/B,MAAM,oBAAoB,OAAO,KAAK,QAAQ;GAC9C,MAAM,IAAIA,sCAAAA,4BACN,0DAA0D,KAAK,OAAO,yBAAyB,kBAAkB,KAAK,IAAI,KAAK,UACnI;EACJ;EAEA,OAAO,QAAQ,IAAI;CACvB;CAIA,aAAa,OAA+C;EACxD,OAAO,IAAI,QACP,KAAK,QACL,KAAK,MACL,KAAK,QACL,OAAO,OAAO;GAAE,GAAG,KAAK;GAAU,GAAG;EAAM,CAAC,CAChD;CACJ;CAEA,WAAW,QAA+B;EACtC,OAAO,IAAI,QAAQ,KAAK,QAAQ,KAAK,MAAM,QAAQ,KAAK,QAAQ;CACpE;CAIA,WAAmB;EACf,MAAM,QAAkB,CAAC,KAAK,MAAM;EACpC,IAAI,KAAK,QAAQ,MAAM,KAAK,WAAW,KAAK,OAAO,EAAE;EACrD,OAAO,WAAW,MAAM,KAAK,IAAI,EAAE;CACvC;AACJ"}

package/dist/outcome.d.cts

@@ -0,0 +1,58 @@
+//#region src/core/result/outcome.d.ts
+/**
+ * Outcome — Business decision abstraction.
+ *
+ * Represents the semantic result of a domain decision, policy evaluation,
+ * or business rule. NOT for technical success/failure — use Result for that.
+ *
+ * Mental model:
+ *   "What was the business decision?"
+ *   NOT "Did the operation succeed?"
+ *
+ * The status axis represents valid business outcomes (APPROVED, REJECTED,
+ * ALLOW, DENY, NO_OP, etc.), never technical Ok/Err.
+ *
+ * @typeParam S - Union of valid status literals for this outcome
+ * @typeParam D - Shape of the decision data carried by this outcome
+ */
+declare class Outcome<S extends string, D = undefined> {
+  readonly status: S;
+  readonly data: D;
+  readonly reason: string | undefined;
+  readonly metadata: Readonly<Record<string, unknown>>;
+  private constructor();
+  static of<S extends string, D = undefined>(status: S, data: D, reason?: string, metadata?: Record<string, unknown>): Outcome<S, D>;
+  static approved<D = undefined>(data: D, reason?: string): Outcome<"APPROVED", D>;
+  static rejected<D = undefined>(data: D, reason: string): Outcome<"REJECTED", D>;
+  static noOp<D = undefined>(data: D, reason?: string): Outcome<"NO_OP", D>;
+  static deferred<D = undefined>(data: D, reason: string): Outcome<"DEFERRED", D>;
+  static requiresReview<D = undefined>(data: D, reason: string): Outcome<"REQUIRES_REVIEW", D>;
+  /**
+   * Narrows this Outcome to a specific status.
+   *
+   * @example
+   * if (outcome.is('DENY')) {
+   *   outcome.data.violations // TS knows status is 'DENY'
+   * }
+   */
+  is<T extends S>(status: T): this is Outcome<T, D>;
+  /**
+   * Exhaustive pattern match over all possible statuses.
+   * TypeScript enforces that every status has a handler.
+   *
+   * @example
+   * outcome.match({
+   *   ALLOW: (o) => handleAllow(o.data),
+   *   DENY:  (o) => handleDeny(o.data.violations),
+   * })
+   */
+  match<THandlers extends { [K in S]: (outcome: Outcome<K, D>) => unknown }>(handlers: THandlers): ReturnType<THandlers[S]>;
+  withMetadata(extra: Record<string, unknown>): Outcome<S, D>;
+  withReason(reason: string): Outcome<S, D>;
+  toString(): string;
+}
+/** Common business outcome statuses. Extend per domain as needed. */
+type CommonOutcomeStatus = "APPROVED" | "REJECTED" | "NO_OP" | "DEFERRED" | "REQUIRES_REVIEW";
+//#endregion
+export { Outcome as n, CommonOutcomeStatus as t };
+//# sourceMappingURL=outcome.d.cts.map

package/dist/outcome.d.ts

@@ -1,85 +1,3 @@
-//#region src/core/result/result.d.ts
-/**
- * Represents the outcome of an operation that may succeed or fail.
- * Useful for avoiding excessive exceptions and making error flows explicit.
- */
-declare abstract class Result<T, E> {
-  protected constructor();
-  /**
-   * Creates a success result containing a value.
-   */
-  static ok<T>(value: T): Result<T, never>;
-  /**
-   * Creates an error result containing an error object.
-   */
-  static err<E>(error: E): Result<never, E>;
-  /**
-   * Returns true when this is a success result.
-   */
-  abstract isOk(): this is Ok<T>;
-  /**
-   * Returns true when this is an error result.
-   */
-  abstract isErr(): this is Err<E>;
-  /**
-   * Runs a handler based on the result state (similar to pattern matching).
-   */
-  abstract match<R>(handlers: {
-    ok: (value: T) => R;
-    err: (error: E) => R;
-  }): R;
-  /**
-   * Returns the value when this is success, or null when this is an error.
-   */
-  getOrNull(): T | null;
-  /**
-   * Returns the error when this is a failure, or null when this is a success.
-   */
-  errorOrNull(): E | null;
-  /**
-   * Returns the value when this is a success, or throws the error when this is a failure.
-   */
-  getOrThrow(): T;
-  /**
-   * Transforms the success value using the provided function. Keeps the error when this is a failure.
-   */
-  map<R>(transform: (value: T) => R): Result<R, E>;
-  /**
-   * Transforms the error using the provided function. Keeps the value when this is a success.
-   */
-  mapError<F>(transform: (error: E) => F): Result<T, F>;
-  /**
-   * Chains another operation that returns a Result when this result is a success.
-   */
-  flatMap<R>(transform: (value: T) => Result<R, E>): Result<R, E>;
-}
-/**
- * Success variant of Result.
- */
-declare class Ok<T> extends Result<T, never> {
-  readonly value: T;
-  constructor(value: T);
-  isOk(): this is Ok<T>;
-  isErr(): this is Err<never>;
-  match<R>(handlers: {
-    ok: (value: T) => R;
-    err: (error: never) => R;
-  }): R;
-}
-/**
- * Error variant of Result.
- */
-declare class Err<E> extends Result<never, E> {
-  readonly error: E;
-  constructor(error: E);
-  isOk(): this is Ok<never>;
-  isErr(): this is Err<E>;
-  match<R>(handlers: {
-    ok: (value: never) => R;
-    err: (error: E) => R;
-  }): R;
-}
-//#endregion
 //#region src/core/result/outcome.d.ts
 /**
  * Outcome — Business decision abstraction.
@@ -136,5 +54,5 @@ declare class Outcome<S extends string, D = undefined> {
 /** Common business outcome statuses. Extend per domain as needed. */
 type CommonOutcomeStatus = "APPROVED" | "REJECTED" | "NO_OP" | "DEFERRED" | "REQUIRES_REVIEW";
 //#endregion
-export { Result as a, Ok as i, Outcome as n, Err as r, CommonOutcomeStatus as t };
+export { Outcome as n, CommonOutcomeStatus as t };
 //# sourceMappingURL=outcome.d.ts.map

package/dist/parse-gate-payload.d.cts

@@ -0,0 +1,62 @@
+import { r as Result } from "./result.cjs";
+import { O as GatePayload, T as PolicyContext, k as GatePayloadV1 } from "./core-config.cjs";
+import { a as ComputeOutcome, c as VersionedComputeEngine, i as ComputeEvaluatorRegistration, l as ComputePayload, p as ComputePayloadV1, r as ComputeEvaluator } from "./gate-engine-registry.cjs";
+
+//#region src/core/policies/engines/compute-evaluator-registry.d.ts
+declare class ComputeEvaluatorRegistry {
+  private readonly evaluators;
+  private static toRegistryKey;
+  register(registration: ComputeEvaluatorRegistration): void;
+  get(policyKey: string, version: number): ComputeEvaluator | undefined;
+}
+//#endregion
+//#region src/core/policies/engines/compute-engine-registry.d.ts
+declare class ComputeEngineRegistry {
+  private readonly engines;
+  register(engine: VersionedComputeEngine): void;
+  get(version: number): VersionedComputeEngine | undefined;
+  evaluate(version: number, params: {
+    readonly policyKey: string;
+    readonly payloadSchemaVersion: number;
+    readonly payload: unknown;
+    readonly context: PolicyContext;
+    readonly evaluators: ComputeEvaluatorRegistry;
+  }): Result<ComputeOutcome, string>;
+}
+//#endregion
+//#region src/core/policies/engines/parse-compute-payload.d.ts
+type ComputePayloadParser = (payload: unknown) => Result<ComputePayload, string>;
+declare class ComputePayloadParserRegistry {
+  private readonly parsers;
+  register(payloadSchemaVersion: number, parser: ComputePayloadParser): void;
+  get(payloadSchemaVersion: number): ComputePayloadParser | undefined;
+  parse(payloadSchemaVersion: number, payload: unknown): Result<ComputePayloadV1, string>;
+}
+declare class ComputePayloadParsers {
+  private static readonly registry;
+  private static defaultsRegistered;
+  private static ensureDefaults;
+  static register(payloadSchemaVersion: number, parser: ComputePayloadParser): void;
+  static get(payloadSchemaVersion: number): ComputePayloadParser | undefined;
+  static parse(payloadSchemaVersion: number, payload: unknown): Result<ComputePayloadV1, string>;
+}
+//#endregion
+//#region src/core/policies/engines/parse-gate-payload.d.ts
+type GatePayloadParser = (payload: unknown) => Result<GatePayload, string>;
+declare class GatePayloadParserRegistry {
+  private readonly parsers;
+  register(engineVersion: number, parser: GatePayloadParser): void;
+  get(engineVersion: number): GatePayloadParser | undefined;
+  parse(engineVersion: number, payload: unknown): Result<GatePayloadV1, string>;
+}
+declare class GatePayloadParsers {
+  private static readonly registry;
+  private static defaultsRegistered;
+  private static ensureDefaults;
+  static register(engineVersion: number, parser: GatePayloadParser): void;
+  static get(engineVersion: number): GatePayloadParser | undefined;
+  static parse(engineVersion: number, payload: unknown): Result<GatePayloadV1, string>;
+}
+//#endregion
+export { ComputePayloadParserRegistry as a, ComputeEvaluatorRegistry as c, ComputePayloadParser as i, GatePayloadParserRegistry as n, ComputePayloadParsers as o, GatePayloadParsers as r, ComputeEngineRegistry as s, GatePayloadParser as t };
+//# sourceMappingURL=parse-gate-payload.d.cts.map

package/dist/parse-gate-payload.d.ts

@@ -1,5 +1,5 @@
-import { a as Result } from "./outcome.js";
-import { d as GatePayloadV1, s as PolicyContext, u as GatePayload } from "./gate-types.js";
+import { r as Result } from "./result.js";
+import { O as GatePayload, T as PolicyContext, k as GatePayloadV1 } from "./core-config.js";
 import { a as ComputeOutcome, c as VersionedComputeEngine, i as ComputeEvaluatorRegistration, l as ComputePayload, p as ComputePayloadV1, r as ComputeEvaluator } from "./gate-engine-registry.js";
 
 //#region src/core/policies/engines/compute-evaluator-registry.d.ts

package/dist/path.d.cts

@@ -0,0 +1,90 @@
+import { r as Result } from "./result.cjs";
+import { t as CoreConfig } from "./core-config.cjs";
+import { D as PolicyDefinition, N as PolicyCatalog, P as PolicyCatalogEntryProps, S as PolicyDefinitionRepository, T as FindCandidatesParams, m as ContextResolverRegistry, y as ContextValueResolver } from "./policy-service.cjs";
+import { i as ComputeEvaluatorRegistration } from "./gate-engine-registry.cjs";
+
+//#region src/core/config/core-config.instance.d.ts
+
+/**
+ * Shared instance for the application composition root.
+ * Use `new CoreConfig()` for isolated runtimes, tests, or multi-tenant hosts.
+ *
+ * The default reporter is silent so the core has no runtime logging dependency.
+ * Hosts can swap in their own `PolicyReporter` via
+ * `coreConfig.configure({ observability: { reporter } })`.
+ */
+declare const coreConfig: CoreConfig;
+//#endregion
+//#region src/core/policies/utils/hash.d.ts
+/**
+ * Produces a deterministic SHA-256 hex digest of a canonical JSON representation.
+ * Object keys are sorted recursively so key order does not affect the hash.
+ * Array item order is preserved on purpose; callers that treat arrays as sets
+ * must normalize or sort them before hashing.
+ *
+ * Values that JSON.stringify would silently drop or coerce (undefined,
+ * non-finite numbers, functions, symbols, bigint) are rejected up-front to
+ * prevent semantically different payloads from collapsing to the same hash.
+ */
+declare class PolicyHashing {
+  static sha256(input: string): string;
+  private static assertHashable;
+  static canonicalJson(value: unknown): string;
+  static computePayloadHash(payload: unknown, policyKey: string, policyVersion: string): string;
+}
+//#endregion
+//#region src/core/policies/defs/in-memory-policy-definition-repo.d.ts
+declare class InMemoryPolicyDefinitionRepository implements PolicyDefinitionRepository {
+  private readonly definitions;
+  private readonly definitionsByPolicyKey;
+  constructor(definitions: readonly PolicyDefinition[]);
+  findCandidates(params: FindCandidatesParams): PolicyDefinition[];
+}
+//#endregion
+//#region src/core/policies/package/policy-package.d.ts
+/**
+ * Protocol of contribution: a module declares what it wants to add to the
+ * policy system without the core knowing which module it is.
+ *
+ * - catalogEntries: static policy descriptors the catalog will register.
+ * - definitions:   default policy definitions (rules/parameters) to seed.
+ * - evaluators:    compute evaluator registrations keyed by policy/version.
+ */
+interface PolicyPackage {
+  readonly catalogEntries: readonly PolicyCatalogEntryProps[];
+  readonly definitions: readonly PolicyDefinition[];
+  readonly evaluators: readonly ComputeEvaluatorRegistration[];
+}
+//#endregion
+//#region src/core/policies/catalog/catalog.instance.d.ts
+/**
+ * Aggregates catalog entries contributed by each module package into a single
+ * PolicyCatalog. The core knows nothing about concrete modules — callers
+ * are responsible for passing all relevant packages at composition time.
+ */
+declare class PolicyCatalogFactory {
+  static build(packages: readonly PolicyPackage[]): PolicyCatalog;
+}
+//#endregion
+//#region src/core/policies/context/context-registry.instance.d.ts
+/**
+ * Official instance of the ContextResolverRegistry.
+ * Use `new ContextResolverRegistry()` plus `registerNamespacedContextResolversIn`
+ * when each runtime/composition root needs its own isolated resolver graph.
+ */
+declare const contextResolverRegistry: ContextResolverRegistry;
+declare function registerNamespacedContextResolvers(namespace: string, resolvers: readonly ContextValueResolver[]): Result<ContextResolverRegistry, string>;
+//#endregion
+//#region src/core/policies/context/path.d.ts
+declare class PolicyContextPath {
+  private static readonly FORBIDDEN_SEGMENTS;
+  private static resolve;
+  private static parseSegments;
+  private static isPlainRecord;
+  static getOrAbsent(obj: Record<string, unknown>, path: string): Result<unknown, "absent">;
+  static has(obj: Record<string, unknown>, path: string): boolean;
+  static set(obj: Record<string, unknown>, path: string, value: unknown): Result<void, string>;
+}
+//#endregion
+export { PolicyPackage as a, coreConfig as c, PolicyCatalogFactory as i, contextResolverRegistry as n, InMemoryPolicyDefinitionRepository as o, registerNamespacedContextResolvers as r, PolicyHashing as s, PolicyContextPath as t };
+//# sourceMappingURL=path.d.cts.map

package/dist/path.d.ts

@@ -1,5 +1,5 @@
-import { a as Result } from "./outcome.js";
-import { m as CoreConfig } from "./gate-types.js";
+import { r as Result } from "./result.js";
+import { t as CoreConfig } from "./core-config.js";
 import { D as PolicyDefinition, N as PolicyCatalog, P as PolicyCatalogEntryProps, S as PolicyDefinitionRepository, T as FindCandidatesParams, m as ContextResolverRegistry, y as ContextValueResolver } from "./policy-service.js";
 import { i as ComputeEvaluatorRegistration } from "./gate-engine-registry.js";
 

package/dist/plugin.cjs

@@ -0,0 +1,79 @@
+//#region src/core/plugins/plugin.ts
+/**
+* Registry that holds a set of plugins implementing a shared {@link PluginContract}
+* and resolves which of them answer a given extension point.
+*
+* Plugins are kept sorted by priority (descending). For a given method,
+* {@link invoke} either delegates to the highest-priority enabled plugin
+* (`'first'`) or folds every enabled plugin into a single value (`'pipeline'`).
+* When no plugin is enabled, the supplied `fallback` runs instead, so the host
+* always has defined behaviour even with an empty registry.
+*
+* @typeParam P - The plugin contract this manager coordinates.
+*/
+var PluginManager = class {
+	constructor() {
+		this.plugins = [];
+	}
+	/** Registers one or more plugins and re-sorts by priority. */
+	register(...plugins) {
+		this.plugins.push(...plugins);
+		this.reorder();
+	}
+	/** Removes a previously registered plugin by name. */
+	unregister(name) {
+		this.plugins = this.plugins.filter((p) => p.name !== name);
+	}
+	/** Enables a registered plugin by name. */
+	enable(name) {
+		const plugin = this.plugins.find((p) => p.name === name);
+		if (plugin) plugin.enabled = true;
+	}
+	/** Disables a registered plugin by name (without removing it). */
+	disable(name) {
+		const plugin = this.plugins.find((p) => p.name === name);
+		if (plugin) plugin.enabled = false;
+	}
+	/** Lists enabled plugins only, already in priority order. */
+	list() {
+		return this.plugins.filter((p) => p.enabled !== false);
+	}
+	/**
+	* Resolves `method` against the registered plugins.
+	*
+	* In `'first'` mode the highest-priority enabled plugin that implements
+	* `method` answers. In `'pipeline'` mode every enabled plugin runs and the
+	* results are folded with `reducer` (defaults to "keep the last result").
+	* When no enabled plugin implements `method`, `fallback` is called.
+	*/
+	invoke(method, args, opts) {
+		const { mode = "first", fallback, reducer } = opts;
+		const enabled = this.list().filter((p) => method in p);
+		if (enabled.length === 0) return fallback(...args);
+		if (mode === "first") {
+			const fn = enabled[0][method];
+			return fn(...args);
+		}
+		const defaultReducer = (_, curr) => curr;
+		const red = reducer ?? defaultReducer;
+		let acc = enabled[0][method](...args);
+		enabled.slice(1).forEach((plugin, idx) => {
+			const res = plugin[method](...args);
+			acc = red(acc, res, plugin, idx + 1);
+		});
+		return acc;
+	}
+	/** Re-sorts the internal list by priority (desc; default priority = 0). */
+	reorder() {
+		this.plugins.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+	}
+};
+//#endregion
+Object.defineProperty(exports, "PluginManager", {
+	enumerable: true,
+	get: function() {
+		return PluginManager;
+	}
+});
+
+//# sourceMappingURL=plugin.cjs.map

package/dist/plugin.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.cjs","names":[],"sources":["../src/core/plugins/plugin.ts"],"sourcesContent":["import {\n    type BasePlugin,\n    type InvokeOptions,\n    type PipelineReducer,\n    type PluginContract,\n} from \"./types.js\";\n\n/**\n * Registry that holds a set of plugins implementing a shared {@link PluginContract}\n * and resolves which of them answer a given extension point.\n *\n * Plugins are kept sorted by priority (descending). For a given method,\n * {@link invoke} either delegates to the highest-priority enabled plugin\n * (`'first'`) or folds every enabled plugin into a single value (`'pipeline'`).\n * When no plugin is enabled, the supplied `fallback` runs instead, so the host\n * always has defined behaviour even with an empty registry.\n *\n * @typeParam P - The plugin contract this manager coordinates.\n */\nclass PluginManager<P extends PluginContract> {\n    /** Internal list, kept sorted by priority (desc). */\n    private plugins: (P & BasePlugin)[] = [];\n\n    /** Registers one or more plugins and re-sorts by priority. */\n    public register(...plugins: (P & BasePlugin)[]): void {\n        this.plugins.push(...plugins);\n        this.reorder();\n    }\n\n    /** Removes a previously registered plugin by name. */\n    public unregister(name: string): void {\n        this.plugins = this.plugins.filter((p) => p.name !== name);\n    }\n\n    /** Enables a registered plugin by name. */\n    public enable(name: string): void {\n        const plugin = this.plugins.find((p) => p.name === name);\n        if (plugin) plugin.enabled = true;\n    }\n\n    /** Disables a registered plugin by name (without removing it). */\n    public disable(name: string): void {\n        const plugin = this.plugins.find((p) => p.name === name);\n        if (plugin) plugin.enabled = false;\n    }\n\n    /** Lists enabled plugins only, already in priority order. */\n    public list(): readonly (P & BasePlugin)[] {\n        return this.plugins.filter((p) => p.enabled !== false);\n    }\n\n    /**\n     * Resolves `method` against the registered plugins.\n     *\n     * In `'first'` mode the highest-priority enabled plugin that implements\n     * `method` answers. In `'pipeline'` mode every enabled plugin runs and the\n     * results are folded with `reducer` (defaults to \"keep the last result\").\n     * When no enabled plugin implements `method`, `fallback` is called.\n     */\n    public invoke<K extends keyof P>(\n        method: K,\n        args: Parameters<P[K]>,\n        opts: InvokeOptions<P, K>,\n    ): ReturnType<P[K]> {\n        const { mode = \"first\", fallback, reducer } = opts;\n        const enabled = this.list().filter((p) => method in p) as Array<\n            P & BasePlugin\n        >;\n\n        if (enabled.length === 0) {\n            return (fallback as P[K])(...args);\n        }\n\n        if (mode === \"first\") {\n            const fn = enabled[0][method] as P[K];\n            return fn(...args);\n        }\n\n        const defaultReducer: PipelineReducer<ReturnType<P[K]>, P> = (\n            _,\n            curr,\n        ) => curr;\n        const red = reducer ?? defaultReducer;\n\n        let acc: ReturnType<P[K]> = enabled[0][method]!(...args);\n        enabled.slice(1).forEach((plugin, idx) => {\n            const res = plugin[method]!(...args);\n            acc = red(acc, res, plugin, idx + 1);\n        });\n        return acc;\n    }\n\n    /** Re-sorts the internal list by priority (desc; default priority = 0). */\n    private reorder(): void {\n        this.plugins.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));\n    }\n}\n\nexport { PluginManager };\n"],"mappings":";;;;;;;;;;;;;AAmBA,IAAM,gBAAN,MAA8C;;iBAEJ,CAAC;;;CAGvC,SAAgB,GAAG,SAAmC;EAClD,KAAK,QAAQ,KAAK,GAAG,OAAO;EAC5B,KAAK,QAAQ;CACjB;;CAGA,WAAkB,MAAoB;EAClC,KAAK,UAAU,KAAK,QAAQ,QAAQ,MAAM,EAAE,SAAS,IAAI;CAC7D;;CAGA,OAAc,MAAoB;EAC9B,MAAM,SAAS,KAAK,QAAQ,MAAM,MAAM,EAAE,SAAS,IAAI;EACvD,IAAI,QAAQ,OAAO,UAAU;CACjC;;CAGA,QAAe,MAAoB;EAC/B,MAAM,SAAS,KAAK,QAAQ,MAAM,MAAM,EAAE,SAAS,IAAI;EACvD,IAAI,QAAQ,OAAO,UAAU;CACjC;;CAGA,OAA2C;EACvC,OAAO,KAAK,QAAQ,QAAQ,MAAM,EAAE,YAAY,KAAK;CACzD;;;;;;;;;CAUA,OACI,QACA,MACA,MACgB;EAChB,MAAM,EAAE,OAAO,SAAS,UAAU,YAAY;EAC9C,MAAM,UAAU,KAAK,KAAK,EAAE,QAAQ,MAAM,UAAU,CAAC;EAIrD,IAAI,QAAQ,WAAW,GACnB,OAAQ,SAAkB,GAAG,IAAI;EAGrC,IAAI,SAAS,SAAS;GAClB,MAAM,KAAK,QAAQ,GAAG;GACtB,OAAO,GAAG,GAAG,IAAI;EACrB;EAEA,MAAM,kBACF,GACA,SACC;EACL,MAAM,MAAM,WAAW;EAEvB,IAAI,MAAwB,QAAQ,GAAG,QAAS,GAAG,IAAI;EACvD,QAAQ,MAAM,CAAC,EAAE,SAAS,QAAQ,QAAQ;GACtC,MAAM,MAAM,OAAO,QAAS,GAAG,IAAI;GACnC,MAAM,IAAI,KAAK,KAAK,QAAQ,MAAM,CAAC;EACvC,CAAC;EACD,OAAO;CACX;;CAGA,UAAwB;EACpB,KAAK,QAAQ,MAAM,GAAG,OAAO,EAAE,YAAY,MAAM,EAAE,YAAY,EAAE;CACrE;AACJ"}