@cullet/erp-core 1.1.0 → 1.3.0

package/dist/outcome.d.cts

@@ -0,0 +1,140 @@
+//#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.
+ *
+ * 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 { Result as a, Ok as i, Outcome as n, Err as r, CommonOutcomeStatus as t };
+//# sourceMappingURL=outcome.d.cts.map

package/dist/outcome.d.ts

@@ -0,0 +1,140 @@
+//#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.
+ *
+ * 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 { Result as a, Ok as i, Outcome as n, Err as r, CommonOutcomeStatus as t };
+//# sourceMappingURL=outcome.d.ts.map

package/dist/outcome.js

@@ -1,4 +1,4 @@
-import { i as InvariantViolationException } from "./temporal-guards.js";
+import { t as InvariantViolationException } from "./invariant-violation-exception.js";
 //#region src/core/result/outcome.ts
 /**
 * Outcome — Business decision abstraction.

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

@@ -0,0 +1,62 @@
+import { a as Result } from "./outcome.cjs";
+import { d as GatePayloadV1, s as PolicyContext, u as GatePayload } from "./gate-types.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,4 +1,5 @@
-import { I as Result, d as GatePayloadV1, s as PolicyContext, u as GatePayload } from "./gate-types.js";
+import { a as Result } from "./outcome.js";
+import { d as GatePayloadV1, s as PolicyContext, u as GatePayload } from "./gate-types.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 { a as Result } from "./outcome.cjs";
+import { m as CoreConfig } from "./gate-types.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,4 +1,5 @@
-import { I as Result, g as CoreConfig } from "./gate-types.js";
+import { a as Result } from "./outcome.js";
+import { m as CoreConfig } from "./gate-types.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"}

package/dist/plugin.d.cts

@@ -0,0 +1,85 @@
+//#region src/core/plugins/types.d.ts
+/**
+ * Common shape every plugin shares, regardless of the contract it implements.
+ * Carries the metadata the {@link PluginManager} uses to identify, order and
+ * toggle plugins.
+ */
+interface BasePlugin {
+  /** Unique identifier, used for logs / debugging and for enable/disable. */
+  readonly name: string;
+  /** Weight; the highest priority wins (default = 0). */
+  readonly priority?: number;
+  /** Shortcut to disable a plugin without removing it. */
+  enabled?: boolean;
+}
+/**
+ * A plugin contract is a record whose values are the methods plugins may
+ * implement for a given extension point.
+ *
+ * `any` here is intentional: it is the only way to express the constraint
+ * "a record whose values are arbitrary functions". Using `unknown` for the
+ * parameters breaks assignment of concrete contracts by contravariance —
+ * TypeScript rejects functions with specific parameters as a subtype of
+ * `(...args: unknown[]) => unknown`.
+ */
+type PluginContract = Record<string, (...args: any[]) => any>;
+/**
+ * Reducer used in `pipeline` mode to combine the result of each plugin into a
+ * single accumulated value.
+ */
+type PipelineReducer<R, P extends PluginContract> = (accumulated: R, current: R, plugin: P & BasePlugin, index: number) => R;
+/** Options accepted by {@link PluginManager.invoke}. */
+interface InvokeOptions<P extends PluginContract, K extends keyof P> {
+  /**
+   * `'first'`    → returns the first enabled plugin with the highest priority.
+   * `'pipeline'` → runs every enabled plugin, combining results via `reducer`.
+   * default = `'first'`.
+   */
+  mode?: "first" | "pipeline";
+  /** Executed when no plugin is enabled for the method. */
+  fallback: P[K];
+  /** Reducer used only when `mode = "pipeline"`. */
+  reducer?: PipelineReducer<ReturnType<P[K]>, P>;
+}
+//#endregion
+//#region src/core/plugins/plugin.d.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.
+ */
+declare class PluginManager<P extends PluginContract> {
+  /** Internal list, kept sorted by priority (desc). */
+  private plugins;
+  /** Registers one or more plugins and re-sorts by priority. */
+  register(...plugins: (P & BasePlugin)[]): void;
+  /** Removes a previously registered plugin by name. */
+  unregister(name: string): void;
+  /** Enables a registered plugin by name. */
+  enable(name: string): void;
+  /** Disables a registered plugin by name (without removing it). */
+  disable(name: string): void;
+  /** Lists enabled plugins only, already in priority order. */
+  list(): readonly (P & BasePlugin)[];
+  /**
+   * 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<K extends keyof P>(method: K, args: Parameters<P[K]>, opts: InvokeOptions<P, K>): ReturnType<P[K]>;
+  /** Re-sorts the internal list by priority (desc; default priority = 0). */
+  private reorder;
+}
+//#endregion
+export { PluginContract as a, PipelineReducer as i, BasePlugin as n, InvokeOptions as r, PluginManager as t };
+//# sourceMappingURL=plugin.d.cts.map