trigger_system 1.2.1 → 1.2.5

package/dist/core/action-registry.d.ts

@@ -1,12 +1,38 @@
+import { type Type } from "arktype";
 import type { TriggerAction, TriggerContext } from "../types";
 export type ActionHandler = (action: TriggerAction, context: TriggerContext) => Promise<any> | any;
+/**
+ * Built-in action types to avoid magic strings
+ */
+export declare const BuiltInAction: {
+    readonly LOG: "LOG";
+    readonly MATH: "MATH";
+    readonly RESPONSE: "RESPONSE";
+    readonly EXECUTE: "EXECUTE";
+    readonly FORWARD: "FORWARD";
+    readonly STATE_SET: "STATE_SET";
+    readonly STATE_INCREMENT: "STATE_INCREMENT";
+    readonly STATE_GET: "STATE_GET";
+    readonly STATE_DELETE: "STATE_DELETE";
+    readonly EMIT_EVENT: "EMIT_EVENT";
+    readonly NOTIFY: "NOTIFY";
+    readonly STATE_OP: "STATE_OP";
+};
+export interface ActionDefinition {
+    handler: ActionHandler;
+    description?: string;
+    params?: Type;
+    returns?: Type;
+}
 export declare class ActionRegistry {
     private static instance;
-    private handlers;
+    private actions;
     private constructor();
-    static getInstance(): ActionRegistry;
-    register(type: string, handler: ActionHandler): void;
+    static getInstance(autoRegisterDefaults?: boolean): ActionRegistry;
+    register(type: string, handlerOrDef: ActionHandler | ActionDefinition): void;
     get(type: string): ActionHandler | undefined;
+    getDefinition(type: string): ActionDefinition | undefined;
+    getDefinitions(): Record<string, ActionDefinition>;
     get Handlers(): Map<string, ActionHandler>;
     private registerDefaults;
 }

package/dist/core/action-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"action-registry.d.ts","sourceRoot":"","sources":["../../src/core/action-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAI9D,MAAM,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;AAEnG,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAoC;IAEpD,OAAO;IAIP,MAAM,CAAC,WAAW,IAAI,cAAc;IAOpC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa;IAI7C,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAI5C,IAAI,QAAQ,IAAI,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAEzC;IAED,OAAO,CAAC,gBAAgB;CA0KzB"}
+{"version":3,"file":"action-registry.d.ts","sourceRoot":"","sources":["../../src/core/action-registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,IAAI,EAAE,MAAM,SAAS,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAI9D,MAAM,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;AAEnG;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;CAahB,CAAC;AAEX,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,aAAa,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,IAAI,CAAC;IACd,OAAO,CAAC,EAAE,IAAI,CAAC;CAChB;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAiB;IACxC,OAAO,CAAC,OAAO,CAAuC;IAEtD,OAAO;IAMP,MAAM,CAAC,WAAW,CAAC,oBAAoB,GAAE,OAAc,GAAG,cAAc;IAOxE,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,aAAa,GAAG,gBAAgB;IASrE,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAI5C,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAIzD,cAAc,IAAI,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAQlD,IAAI,QAAQ,IAAI,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAMzC;IAED,OAAO,CAAC,gBAAgB;CAkQzB"}

package/dist/core/base-engine.d.ts

@@ -1,11 +1,11 @@
 /**
- * Base Engine Interface - Define la interfaz común para todos los motores
- * Platform-agnostic y extensible
+ * Base Engine Interface - Defines the common interface for all engines
+ * Platform-agnostic and extensible
  */
 import type { TriggerRule, TriggerContext, TriggerResult, RuleEngineConfig, ActionParams } from "../types";
 export type EngineActionHandler = (params: ActionParams, context: TriggerContext) => Promise<unknown> | unknown;
 /**
- * Interfaz base que deben implementar todos los motores
+ * Base interface that all engines must implement
  */
 export interface ITriggerEngine {
     readonly rules: TriggerRule[];

package/dist/core/constants.d.ts

@@ -0,0 +1,95 @@
+import { EngineEvent, RuleEvent } from "../utils/emitter";
+/**
+ * Global constants for the Trigger System to avoid magic strings.
+ */
+export declare const Actions: {
+    readonly LOG: "LOG";
+    readonly MATH: "MATH";
+    readonly RESPONSE: "RESPONSE";
+    readonly EXECUTE: "EXECUTE";
+    readonly FORWARD: "FORWARD";
+    readonly STATE_SET: "STATE_SET";
+    readonly STATE_INCREMENT: "STATE_INCREMENT";
+    readonly STATE_GET: "STATE_GET";
+    readonly STATE_DELETE: "STATE_DELETE";
+    readonly EMIT_EVENT: "EMIT_EVENT";
+    readonly NOTIFY: "NOTIFY";
+    readonly STATE_OP: "STATE_OP";
+};
+export declare const Events: typeof EngineEvent;
+export declare const RuleEvents: typeof RuleEvent;
+/**
+ * Control flow property names
+ */
+export declare const ControlFlow: {
+    readonly IF: "if";
+    readonly THEN: "then";
+    readonly ELSE: "else";
+    readonly BREAK: "break";
+    readonly CONTINUE: "continue";
+    readonly MODE: "mode";
+    readonly ACTIONS: "actions";
+    readonly RUN: "run";
+    readonly DELAY: "delay";
+    readonly PROBABILITY: "probability";
+    readonly PARAMS: "params";
+    readonly TYPE: "type";
+    readonly ON: "on";
+};
+export declare const ErrorMessages: {
+    readonly UNKNOWN_ACTION: "Unknown or generic action type";
+    readonly MISSING_ACTION_TYPE: "Action has no type and no control flow properties";
+    readonly PROBABILITY_FAILED: "probability check failed";
+    readonly BUN_REQUIRED: "Bun is required for 'execute' action";
+    readonly MISSING_KEY: "Missing key for state operation";
+};
+export declare const DebugMessages: {
+    readonly RULE_ENGINE_EVALUATING: (count: number, event: string) => string;
+    readonly TRIGGER_ENGINE_EVALUATING: (count: number, event: string) => string;
+};
+export declare const TriggerSystem: {
+    Actions: {
+        readonly LOG: "LOG";
+        readonly MATH: "MATH";
+        readonly RESPONSE: "RESPONSE";
+        readonly EXECUTE: "EXECUTE";
+        readonly FORWARD: "FORWARD";
+        readonly STATE_SET: "STATE_SET";
+        readonly STATE_INCREMENT: "STATE_INCREMENT";
+        readonly STATE_GET: "STATE_GET";
+        readonly STATE_DELETE: "STATE_DELETE";
+        readonly EMIT_EVENT: "EMIT_EVENT";
+        readonly NOTIFY: "NOTIFY";
+        readonly STATE_OP: "STATE_OP";
+    };
+    Events: typeof EngineEvent;
+    RuleEvents: typeof RuleEvent;
+    ControlFlow: {
+        readonly IF: "if";
+        readonly THEN: "then";
+        readonly ELSE: "else";
+        readonly BREAK: "break";
+        readonly CONTINUE: "continue";
+        readonly MODE: "mode";
+        readonly ACTIONS: "actions";
+        readonly RUN: "run";
+        readonly DELAY: "delay";
+        readonly PROBABILITY: "probability";
+        readonly PARAMS: "params";
+        readonly TYPE: "type";
+        readonly ON: "on";
+    };
+    ErrorMessages: {
+        readonly UNKNOWN_ACTION: "Unknown or generic action type";
+        readonly MISSING_ACTION_TYPE: "Action has no type and no control flow properties";
+        readonly PROBABILITY_FAILED: "probability check failed";
+        readonly BUN_REQUIRED: "Bun is required for 'execute' action";
+        readonly MISSING_KEY: "Missing key for state operation";
+    };
+    DebugMessages: {
+        readonly RULE_ENGINE_EVALUATING: (count: number, event: string) => string;
+        readonly TRIGGER_ENGINE_EVALUATING: (count: number, event: string) => string;
+    };
+};
+export default TriggerSystem;
+//# sourceMappingURL=constants.d.ts.map

package/dist/core/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/core/constants.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE1D;;GAEG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;CAAgB,CAAC;AACrC,eAAO,MAAM,MAAM,oBAAc,CAAC;AAClC,eAAO,MAAM,UAAU,kBAAY,CAAC;AAEpC;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;CAcd,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;CAMhB,CAAC;AAEX,eAAO,MAAM,aAAa;6CACU,MAAM,SAAS,MAAM;gDAClB,MAAM,SAAS,MAAM;CAClD,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDAJU,MAAM,SAAS,MAAM;oDAClB,MAAM,SAAS,MAAM;;CAU3D,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/dist/core/dependency-graph/analyzer.d.ts

@@ -0,0 +1,60 @@
+/**
+ * DependencyAnalyzer
+ * Analyzes static rules to detect circular dependencies (infinite loops)
+ * and provides detailed JSON export with full rule information.
+ *
+ * This class provides backwards compatibility while delegating to modular functions.
+ *
+ * Graph:
+ * - Nodes: Rules
+ * - Edges: Rule A -> Rule B (if A emits an event that B listens for)
+ */
+import type { TriggerRule } from "../../types";
+import type { DependencyGraph, DependencyAnalysisResult, RuleDependencies, ValidationResult } from "./types";
+/**
+ * DependencyAnalyzer - Main class for dependency analysis
+ * Provides backwards compatibility for existing code
+ */
+export declare class DependencyAnalyzer {
+    /**
+     * Build complete dependency graph with full rule information
+     * @returns JSON-serializable DependencyGraph object
+     */
+    static buildGraph(rules: TriggerRule[]): DependencyGraph;
+    /**
+     * Detects cycles in a list of rules (legacy method for compatibility)
+     * @returns Array of cycles, where each cycle is an array of Rule IDs.
+     */
+    static detectCycles(rules: TriggerRule[]): string[][];
+    /**
+     * Complete dependency analysis with JSON export
+     * @returns DependencyAnalysisResult with full information
+     */
+    static analyze(rules: TriggerRule[]): DependencyAnalysisResult;
+    /**
+     * Export dependency graph as JSON string
+     */
+    static toJSON(rules: TriggerRule[]): string;
+    /**
+     * Export dependency graph as compact JSON string
+     */
+    static toJSONCompact(rules: TriggerRule[]): string;
+    /**
+     * Get dependency info for a specific rule
+     */
+    static getRuleDependencies(rules: TriggerRule[], ruleId: string): RuleDependencies | null;
+    /**
+     * Get all rules that listen to a specific event
+     */
+    static getRulesListeningToEvent(rules: TriggerRule[], event: string): TriggerRule[];
+    /**
+     * Get all rules that emit a specific event
+     */
+    static getRulesEmittingEvent(rules: TriggerRule[], event: string): TriggerRule[];
+    /**
+     * Validate rules and return validation result
+     */
+    static validate(rules: TriggerRule[]): ValidationResult;
+    private static getEmittedEvents;
+}
+//# sourceMappingURL=analyzer.d.ts.map

package/dist/core/dependency-graph/analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../../../src/core/dependency-graph/analyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EACV,eAAe,EACf,wBAAwB,EACxB,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,SAAS,CAAC;AA6BjB;;;GAGG;AACH,qBAAa,kBAAkB;IAE7B;;;OAGG;IACH,MAAM,CAAC,UAAU,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,eAAe;IAIxD;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,MAAM,EAAE,EAAE;IAIrD;;;OAGG;IACH,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,wBAAwB;IAI9D;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,MAAM;IAK3C;;OAEG;IACH,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,MAAM;IAKlD;;OAEG;IACH,MAAM,CAAC,mBAAmB,CACxB,KAAK,EAAE,WAAW,EAAE,EACpB,MAAM,EAAE,MAAM,GACb,gBAAgB,GAAG,IAAI;IAmB1B;;OAEG;IACH,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,WAAW,EAAE;IAInF;;OAEG;IACH,MAAM,CAAC,qBAAqB,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,WAAW,EAAE;IAIhF;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,gBAAgB;IAKvD,OAAO,CAAC,MAAM,CAAC,gBAAgB;CAGhC"}

package/dist/core/dependency-graph/builder.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Dependency Graph Builder
+ * Functions for building the dependency graph from rules
+ */
+import type { TriggerRule } from "../../types";
+import type { DependencyGraph, DependencyNode, DependencyEdge } from "./types";
+/**
+ * Build complete dependency graph with full rule information
+ * @returns JSON-serializable DependencyGraph object
+ */
+export declare function buildGraph(rules: TriggerRule[]): DependencyGraph;
+/**
+ * Build an adjacency list from rules (simplified version)
+ */
+export declare function buildAdjacencyList(rules: TriggerRule[]): Record<string, string[]>;
+/**
+ * Build a reverse adjacency list from rules (simplified version)
+ */
+export declare function buildReverseAdjacencyList(rules: TriggerRule[]): Record<string, string[]>;
+/**
+ * Get all edges in the graph
+ */
+export declare function getAllEdges(rules: TriggerRule[]): DependencyEdge[];
+/**
+ * Get all nodes in the graph
+ */
+export declare function getAllNodes(rules: TriggerRule[]): DependencyNode[];
+//# sourceMappingURL=builder.d.ts.map

package/dist/core/dependency-graph/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../../src/core/dependency-graph/builder.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAG/E;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,eAAe,CAuEhE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAGjF;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAGxF;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,cAAc,EAAE,CAGlE;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,cAAc,EAAE,CAGlE"}

package/dist/core/dependency-graph/cycles.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Cycle Detection Module
+ * Functions for detecting cycles in the dependency graph
+ */
+import type { TriggerRule } from "../../types";
+import type { DependencyGraph, CycleInfo } from "./types";
+/**
+ * Detect cycles in a list of rules (legacy method for compatibility)
+ * @returns Array of cycles, where each cycle is an array of Rule IDs.
+ */
+export declare function detectCycles(rules: TriggerRule[]): string[][];
+/**
+ * Detect cycles with full rule information
+ */
+export declare function detectCyclesWithInfo(rules: TriggerRule[], graph: DependencyGraph): CycleInfo[];
+/**
+ * Check if adding a rule would create a cycle
+ */
+export declare function wouldCreateCycle(existingRules: TriggerRule[], newRule: TriggerRule): boolean;
+/**
+ * Get all rules involved in any cycle
+ */
+export declare function getRulesInCycles(rules: TriggerRule[]): Set<string>;
+/**
+ * Calculate maximum cycle length
+ */
+export declare function getMaxCycleLength(rules: TriggerRule[]): number;
+//# sourceMappingURL=cycles.d.ts.map

package/dist/core/dependency-graph/cycles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cycles.d.ts","sourceRoot":"","sources":["../../../src/core/dependency-graph/cycles.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAG1D;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,MAAM,EAAE,EAAE,CAwC7D;AAqCD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE,KAAK,EAAE,eAAe,GAAG,SAAS,EAAE,CAqE9F;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,aAAa,EAAE,WAAW,EAAE,EAC5B,OAAO,EAAE,WAAW,GACnB,OAAO,CAIT;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CAelE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,MAAM,CAK9D"}

package/dist/core/dependency-graph/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Dependency Graph Module
+ * Main entry point for the dependency graph analysis system
+ */
+export type { DependencyEdge, DependencyNode, DependencyGraph, CycleInfo, DependencyAnalysisResult, ValidationResult, RuleDependencies, EventToRulesMap } from './types';
+export { getEmittedEvents, buildEventToRulesMap, getRulesListeningToEvent, getRulesEmittingEvent, findOrphanedRules, isRuleValid, createRuleMap } from './utils';
+export { buildGraph, buildAdjacencyList, buildReverseAdjacencyList, getAllEdges, getAllNodes } from './builder';
+export { detectCycles, detectCyclesWithInfo, wouldCreateCycle, getRulesInCycles, getMaxCycleLength } from './cycles';
+export { validate, analyze, isValid, getErrors, getWarnings } from './validator';
+export { DependencyAnalyzer } from './analyzer';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/dependency-graph/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/dependency-graph/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,YAAY,EACV,cAAc,EACd,cAAc,EACd,eAAe,EACf,SAAS,EACT,wBAAwB,EACxB,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EAChB,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,wBAAwB,EACxB,qBAAqB,EACrB,iBAAiB,EACjB,WAAW,EACX,aAAa,EACd,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,UAAU,EACV,kBAAkB,EAClB,yBAAyB,EACzB,WAAW,EACX,WAAW,EACZ,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,YAAY,EACZ,oBAAoB,EACpB,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,QAAQ,EACR,OAAO,EACP,OAAO,EACP,SAAS,EACT,WAAW,EACZ,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC"}

package/dist/core/dependency-graph/types.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Dependency Graph Types
+ * JSON-serializable types for dependency analysis results
+ */
+import type { TriggerRule, ActionGroup } from "../../types";
+/** Alias for TriggerAction */
+export type { TriggerRule, ActionGroup as TriggerActionGroup };
+/** Represents a single dependency edge in the graph */
+export interface DependencyEdge {
+    sourceRuleId: string;
+    targetRuleId: string;
+    emittedEvent: string;
+    sourceRule: TriggerRule;
+    targetRule: TriggerRule;
+}
+/** Represents a node in the dependency graph */
+export interface DependencyNode {
+    ruleId: string;
+    rule: TriggerRule;
+    listensTo: string[];
+    emits: string[];
+}
+/** Complete dependency graph structure */
+export interface DependencyGraph {
+    nodes: DependencyNode[];
+    edges: DependencyEdge[];
+    adjacencyList: Record<string, string[]>;
+    reverseAdjacencyList: Record<string, string[]>;
+}
+/** Cycle information with full rule details */
+export interface CycleInfo {
+    cycleId: string;
+    rules: TriggerRule[];
+    ruleIds: string[];
+    events: string[];
+    length: number;
+}
+/** Complete analysis result */
+export interface DependencyAnalysisResult {
+    graph: DependencyGraph;
+    cycles: CycleInfo[];
+    orphanedRules: TriggerRule[];
+    potentialInfiniteLoops: CycleInfo[];
+    summary: {
+        totalRules: number;
+        totalEdges: number;
+        cyclesCount: number;
+        orphanedCount: number;
+        maxCycleLength: number;
+    };
+    raw: {
+        rules: TriggerRule[];
+        adjacencyList: Record<string, string[]>;
+        eventToRules: Record<string, string[]>;
+    };
+}
+/** Validation result */
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+    analysis: DependencyAnalysisResult;
+}
+/** Rule dependencies result */
+export interface RuleDependencies {
+    dependsOn: TriggerRule[];
+    dependedBy: TriggerRule[];
+    graph: DependencyGraph;
+}
+/** Event to rules mapping */
+export type EventToRulesMap = Record<string, string[]>;
+//# sourceMappingURL=types.d.ts.map

package/dist/core/dependency-graph/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/core/dependency-graph/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE5D,8BAA8B;AAC9B,YAAY,EAAE,WAAW,EAAE,WAAW,IAAI,kBAAkB,EAAE,CAAC;AAE/D,uDAAuD;AACvD,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,WAAW,CAAC;IACxB,UAAU,EAAE,WAAW,CAAC;CACzB;AAED,gDAAgD;AAChD,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,WAAW,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,0CAA0C;AAC1C,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACxC,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CAChD;AAED,+CAA+C;AAC/C,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,+BAA+B;AAC/B,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,eAAe,CAAC;IACvB,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,aAAa,EAAE,WAAW,EAAE,CAAC;IAC7B,sBAAsB,EAAE,SAAS,EAAE,CAAC;IACpC,OAAO,EAAE;QACP,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,WAAW,EAAE,MAAM,CAAC;QACpB,aAAa,EAAE,MAAM,CAAC;QACtB,cAAc,EAAE,MAAM,CAAC;KACxB,CAAC;IACF,GAAG,EAAE;QACH,KAAK,EAAE,WAAW,EAAE,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;QACxC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;KACxC,CAAC;CACH;AAED,wBAAwB;AACxB,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,wBAAwB,CAAC;CACpC;AAED,+BAA+B;AAC/B,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,WAAW,EAAE,CAAC;IACzB,UAAU,EAAE,WAAW,EAAE,CAAC;IAC1B,KAAK,EAAE,eAAe,CAAC;CACxB;AAED,6BAA6B;AAC7B,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC"}

package/dist/core/dependency-graph/utils.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Dependency Graph Utilities
+ * Helper functions for extracting events from rules and other utilities
+ */
+import type { TriggerRule } from "../../types";
+/**
+ * Extract all events emitted by a rule.
+ * Recursively traverses action groups and arrays to find EMIT_EVENT actions.
+ */
+export declare function getEmittedEvents(rule: TriggerRule): string[];
+/**
+ * Build an event-to-rules mapping from a list of rules.
+ * Maps each event to the list of rule IDs that listen to it.
+ */
+export declare function buildEventToRulesMap(rules: TriggerRule[]): Record<string, string[]>;
+/**
+ * Get rules that listen to a specific event
+ */
+export declare function getRulesListeningToEvent(rules: TriggerRule[], event: string): TriggerRule[];
+/**
+ * Get rules that emit a specific event
+ */
+export declare function getRulesEmittingEvent(rules: TriggerRule[], event: string): TriggerRule[];
+/**
+ * Find rules that are orphaned (no dependencies in or out)
+ */
+export declare function findOrphanedRules(rules: TriggerRule[], adjacencyList: Record<string, string[]>, reverseAdjacencyList: Record<string, string[]>): TriggerRule[];
+/**
+ * Check if a rule has a valid 'on' event
+ */
+export declare function isRuleValid(rule: TriggerRule): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Create a rule map for quick lookups
+ */
+export declare function createRuleMap(rules: TriggerRule[]): Map<string, TriggerRule>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/core/dependency-graph/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/core/dependency-graph/utils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,WAAW,EAA8B,MAAM,aAAa,CAAC;AAE3E;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,EAAE,CA6B5D;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAWnF;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,WAAW,EAAE,CAE3F;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,WAAW,EAAE,CAKxF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,WAAW,EAAE,EACpB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EACvC,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAC7C,WAAW,EAAE,CA0Bf;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,WAAW,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAKjF;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAM5E"}

package/dist/core/dependency-graph/validator.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Validation Module
+ * Functions for validating rules and their dependencies
+ */
+import type { TriggerRule } from "../../types";
+import type { DependencyAnalysisResult, ValidationResult } from "./types";
+/**
+ * Validate rules and return validation result
+ */
+export declare function validate(rules: TriggerRule[]): ValidationResult;
+/**
+ * Complete dependency analysis with JSON export
+ * @returns DependencyAnalysisResult with full information
+ */
+export declare function analyze(rules: TriggerRule[]): DependencyAnalysisResult;
+/**
+ * Check if rules are valid (no cycles)
+ */
+export declare function isValid(rules: TriggerRule[]): boolean;
+/**
+ * Get all validation errors for rules
+ */
+export declare function getErrors(rules: TriggerRule[]): string[];
+/**
+ * Get all validation warnings for rules
+ */
+export declare function getWarnings(rules: TriggerRule[]): string[];
+//# sourceMappingURL=validator.d.ts.map

package/dist/core/dependency-graph/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../../src/core/dependency-graph/validator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAK1E;;GAEG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,gBAAgB,CAkC/D;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,wBAAwB,CAuCtE;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,OAAO,CAErD;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,MAAM,EAAE,CAExD;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,MAAM,EAAE,CAE1D"}

package/dist/core/dependency-graph.d.ts

@@ -1,18 +1,69 @@
-import type { TriggerRule } from "../types";
 /**
- * DependencyAnalyzer
- * Analyzes static rules to detect circular dependencies (infinite loops).
+ * Dependency Graph Module
+ *
+ * This is the main entry point that re-exports all functionality from the
+ * modular sub-modules for backwards compatibility.
  *
- * Graph:
- * - Nodes: Rules
- * - Edges: Rule A -> Rule B (if A emits an event that B listens for)
+ * New code should import from 'src/core/dependency-graph/index.ts' for better
+ * tree-shaking and type safety.
+ */
+import type { TriggerRule } from "../types";
+export type { DependencyEdge, DependencyNode, DependencyGraph, CycleInfo, DependencyAnalysisResult, ValidationResult, RuleDependencies, EventToRulesMap } from './dependency-graph/types';
+export { getEmittedEvents, buildEventToRulesMap, getRulesListeningToEvent, getRulesEmittingEvent, findOrphanedRules, isRuleValid, createRuleMap } from './dependency-graph/utils';
+export { buildGraph, buildAdjacencyList, buildReverseAdjacencyList, getAllEdges, getAllNodes } from './dependency-graph/builder';
+export { detectCycles, detectCyclesWithInfo, wouldCreateCycle, getRulesInCycles, getMaxCycleLength } from './dependency-graph/cycles';
+export { validate, analyze, isValid, getErrors, getWarnings } from './dependency-graph/validator';
+export { DependencyAnalyzer } from './dependency-graph/analyzer';
+/**
+ * Legacy re-exports for backwards compatibility
+ * @deprecated Use named imports from this module instead
  */
-export declare class DependencyAnalyzer {
-    /**
-     * Detects cycles in a list of rules.
-     * @returns Array of cycles, where each cycle is an array of Rule IDs.
-     */
-    static detectCycles(rules: TriggerRule[]): string[][];
-    private static getEmittedEvents;
+export type { TriggerRule, TriggerAction, ActionGroup } from "../types";
+/**
+ * Legacy interface aliases - now delegate to modular types
+ */
+export interface LegacyDependencyEdge {
+    sourceRuleId: string;
+    targetRuleId: string;
+    emittedEvent: string;
+    sourceRule: TriggerRule;
+    targetRule: TriggerRule;
+}
+export interface LegacyDependencyNode {
+    ruleId: string;
+    rule: TriggerRule;
+    listensTo: string[];
+    emits: string[];
+}
+export interface LegacyDependencyGraph {
+    nodes: LegacyDependencyNode[];
+    edges: LegacyDependencyEdge[];
+    adjacencyList: Record<string, string[]>;
+    reverseAdjacencyList: Record<string, string[]>;
+}
+export interface LegacyCycleInfo {
+    cycleId: string;
+    rules: TriggerRule[];
+    ruleIds: string[];
+    events: string[];
+    length: number;
+}
+export interface LegacyDependencyAnalysisResult {
+    graph: LegacyDependencyGraph;
+    cycles: LegacyCycleInfo[];
+    orphanedRules: TriggerRule[];
+    potentialInfiniteLoops: LegacyCycleInfo[];
+    summary: {
+        totalRules: number;
+        totalEdges: number;
+        cyclesCount: number;
+        orphanedCount: number;
+        maxCycleLength: number;
+    };
+    raw: {
+        rules: TriggerRule[];
+        adjacencyList: Record<string, string[]>;
+        eventToRules: Record<string, string[]>;
+    };
 }
 //# sourceMappingURL=dependency-graph.d.ts.map

package/dist/core/dependency-graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dependency-graph.d.ts","sourceRoot":"","sources":["../../src/core/dependency-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAA8B,MAAM,UAAU,CAAC;AAExE;;;;;;;GAOG;AACH,qBAAa,kBAAkB;IAE3B;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,MAAM,EAAE,EAAE;IAiErD,OAAO,CAAC,MAAM,CAAC,gBAAgB;CA6BlC"}
+{"version":3,"file":"dependency-graph.d.ts","sourceRoot":"","sources":["../../src/core/dependency-graph.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,WAAW,EAA8B,MAAM,UAAU,CAAC;AAGxE,YAAY,EACV,cAAc,EACd,cAAc,EACd,eAAe,EACf,SAAS,EACT,wBAAwB,EACxB,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EAChB,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,wBAAwB,EACxB,qBAAqB,EACrB,iBAAiB,EACjB,WAAW,EACX,aAAa,EACd,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,UAAU,EACV,kBAAkB,EAClB,yBAAyB,EACzB,WAAW,EACX,WAAW,EACZ,MAAM,4BAA4B,CAAC;AAGpC,OAAO,EACL,YAAY,EACZ,oBAAoB,EACpB,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,2BAA2B,CAAC;AAGnC,OAAO,EACL,QAAQ,EACR,OAAO,EACP,OAAO,EACP,SAAS,EACT,WAAW,EACZ,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAEjE;;;GAGG;AAGH,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAExE;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,WAAW,CAAC;IACxB,UAAU,EAAE,WAAW,CAAC;CACzB;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,WAAW,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,oBAAoB,EAAE,CAAC;IAC9B,KAAK,EAAE,oBAAoB,EAAE,CAAC;IAC9B,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACxC,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CAChD;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,8BAA8B;IAC7C,KAAK,EAAE,qBAAqB,CAAC;IAC7B,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,aAAa,EAAE,WAAW,EAAE,CAAC;IAC7B,sBAAsB,EAAE,eAAe,EAAE,CAAC;IAC1C,OAAO,EAAE;QACP,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,WAAW,EAAE,MAAM,CAAC;QACpB,aAAa,EAAE,MAAM,CAAC;QACtB,cAAc,EAAE,MAAM,CAAC;KACxB,CAAC;IACF,GAAG,EAAE;QACH,KAAK,EAAE,WAAW,EAAE,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;QACxC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;KACxC,CAAC;CACH"}

package/dist/core/engine-utils.d.ts

@@ -0,0 +1,45 @@
+import type { TriggerContext, RuleCondition, Action, ActionGroup, ExecutedAction, ActionParams, ExecutionMode } from "../types";
+import { ActionRegistry } from "./action-registry";
+/**
+ * Common utilities for engine logic to avoid repetition across different engine implementations
+ */
+export declare class EngineUtils {
+    /**
+     * Evaluates a set of conditions against a context
+     */
+    static evaluateConditions(conditions: RuleCondition | RuleCondition[] | undefined, context: TriggerContext): boolean;
+    /**
+     * Evaluates a single condition or a condition group recursively
+     */
+    private static evaluateRecursiveCondition;
+    /**
+     * Handles action execution common logic including:
+     * - Probability checks
+     * - Delay handling
+     * - Parameter interpolation
+     * - Control flow (break/continue)
+     * - 'run' block execution
+     * - Shorthand syntax normalization
+     */
+    static processSingleActionBase(action: Action, context: TriggerContext, actionRegistry?: ActionRegistry): Promise<{
+        shouldExecute: boolean;
+        executedAction?: ExecutedAction;
+        normalizedAction: Action;
+    }>;
+    /**
+     * Selects an action to execute based on mode and random weights
+     */
+    static selectActions(actions: Action | Action[] | ActionGroup | (Action | ActionGroup)[]): {
+        actionsToExecute: (Action | ActionGroup)[];
+        mode: ExecutionMode;
+    };
+    /**
+     * Deeply interpolates parameters with context variables
+     */
+    static interpolateParams(params: ActionParams, context: TriggerContext): ActionParams;
+    /**
+     * Recursive interpolation for objects and arrays
+     */
+    static interpolateDeep(val: unknown, context: TriggerContext): unknown;
+}
+//# sourceMappingURL=engine-utils.d.ts.map

package/dist/core/engine-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-utils.d.ts","sourceRoot":"","sources":["../../src/core/engine-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EAEd,aAAa,EAGb,MAAM,EACN,WAAW,EACX,cAAc,EACd,YAAY,EAEZ,aAAa,EACd,MAAM,UAAU,CAAC;AAIlB,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD;;GAEG;AACH,qBAAa,WAAW;IAEtB;;OAEG;IACH,MAAM,CAAC,kBAAkB,CACvB,UAAU,EAAE,aAAa,GAAG,aAAa,EAAE,GAAG,SAAS,EACvD,OAAO,EAAE,cAAc,GACtB,OAAO;IAWV;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,0BAA0B;IAkCzC;;;;;;;;OAQG;WACU,uBAAuB,CAClC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,cAAc,EACvB,cAAc,CAAC,EAAE,cAAc,GAC9B,OAAO,CAAC;QACT,aAAa,EAAE,OAAO,CAAC;QACvB,cAAc,CAAC,EAAE,cAAc,CAAC;QAChC,gBAAgB,EAAE,MAAM,CAAA;KACzB,CAAC;IAkGF;;OAEG;IACH,MAAM,CAAC,aAAa,CAClB,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,WAAW,GAAG,CAAC,MAAM,GAAG,WAAW,CAAC,EAAE,GAClE;QAAE,gBAAgB,EAAE,CAAC,MAAM,GAAG,WAAW,CAAC,EAAE,CAAC;QAAC,IAAI,EAAE,aAAa,CAAA;KAAE;IAiCtE;;OAEG;IACH,MAAM,CAAC,iBAAiB,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,GAAG,YAAY;IAQrF;;OAEG;IACH,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO;CAgBvE"}

package/dist/core/engine.d.ts

@@ -18,14 +18,6 @@ export declare class TriggerEngine {
     private evaluateConditions;
     private evaluateSingleCondition;
     private executeRuleActions;
-    /**
-     * Execute nested actions (then/else branches)
-     */
-    private executeNestedActions;
-    /**
-     * Execute a single action with delay and probability support
-     */
-    private executeSingleAction;
     private interpolateParams;
     private interpolateDeep;
 }

package/dist/core/engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/core/engine.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,WAAW,EACX,cAAc,EACd,aAAa,EAMb,YAAY,EAGb,MAAM,UAAU,CAAC;AAKlB,MAAM,MAAM,mBAAmB,GAAG,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;AAEhH,qBAAa,aAAa;IACxB,OAAO,CAAC,KAAK,CAAqB;IAClC,OAAO,CAAC,cAAc,CAA+C;IACrE,OAAO,CAAC,aAAa,CAAkC;gBAG3C,KAAK,GAAE,WAAW,EAAO;IAMrC,OAAO,CAAC,SAAS;IAKjB;;OAEG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB;IAIzD;;OAEG;IACG,YAAY,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IA+BrE,OAAO,CAAC,aAAa;IAMrB,OAAO,CAAC,kBAAkB;IAc1B,OAAO,CAAC,uBAAuB;YAuBjB,kBAAkB;IAwGhC;;OAEG;YACW,oBAAoB;IAqBlC;;OAEG;YACW,mBAAmB;IAqEjC,OAAO,CAAC,iBAAiB;IAkBzB,OAAO,CAAC,eAAe;CAUxB"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/core/engine.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,WAAW,EACX,cAAc,EACd,aAAa,EAMb,YAAY,EAGb,MAAM,UAAU,CAAC;AAKlB,MAAM,MAAM,mBAAmB,GAAG,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;AAEhH,qBAAa,aAAa;IACxB,OAAO,CAAC,KAAK,CAAqB;IAClC,OAAO,CAAC,cAAc,CAA+C;IACrE,OAAO,CAAC,aAAa,CAAkC;gBAG3C,KAAK,GAAE,WAAW,EAAO;IAMrC,OAAO,CAAC,SAAS;IAKjB;;OAEG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB;IAIzD;;OAEG;IACG,YAAY,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IA+BrE,OAAO,CAAC,aAAa;IAMrB,OAAO,CAAC,kBAAkB;IAc1B,OAAO,CAAC,uBAAuB;YAuBjB,kBAAkB;IAwFhC,OAAO,CAAC,iBAAiB;IAkBzB,OAAO,CAAC,eAAe;CAUxB"}