@omega-flow/engine 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1362 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/engine/WorkflowModel.ts
+import Ajv from "ajv";
+import {
+  WorkflowStatus,
+  WorkflowSchema,
+  ContextSchema,
+  EventSchema
+} from "@omega-flow/types";
+
+// src/engine/EdgeModel.ts
+var EdgeModel = class {
+  /**
+   * Creates a new EdgeModel instance.
+   * @param edge - The edge definition from the workflow
+   * @throws Error if edge is missing, has no id, or lacks source/target
+   */
+  constructor(edge) {
+    if (!edge || !edge.id) {
+      throw new Error("Edge must have an id");
+    }
+    if (!edge.source || !edge.target) {
+      throw new Error("Edge must have a source and target");
+    }
+    this.edge = edge;
+  }
+  /**
+   * Gets the unique identifier of this edge.
+   * @returns The edge's ID as a string
+   */
+  getId() {
+    return String(this.edge.id);
+  }
+  /**
+   * Gets the ID of the source (origin) node.
+   * @returns The source node's ID as a string
+   */
+  getSourceNodeId() {
+    return String(this.edge.source);
+  }
+  /**
+   * Gets the source handle identifier (output port).
+   * Handles allow nodes to have multiple outputs (e.g., "true"/"false" for conditions).
+   * @returns The source handle name, or "_" if not specified
+   */
+  getSourceHandle() {
+    return String(this.edge.sourceHandle || "_");
+  }
+  /**
+   * Gets the ID of the target (destination) node.
+   * @returns The target node's ID as a string
+   */
+  getTargetNodeId() {
+    return String(this.edge.target);
+  }
+  /**
+   * Gets the target handle identifier (input port).
+   * @returns The target handle name, or "_" if not specified
+   */
+  getTargetHandle() {
+    return String(this.edge.targetHandle || "_");
+  }
+};
+var EdgeModel_default = EdgeModel;
+
+// src/engine/WorkflowModel.ts
+var _WorkflowModel_instances, startWorkflow_fn, moveToNode_fn, completeWorkflow_fn, log_fn;
+var WorkflowModel = class {
+  /**
+   * Creates a new WorkflowModel instance from a workflow definition.
+   * @param workflow - The workflow definition to execute
+   * @param nodeModels - Map of node type names to their NodeModel classes
+   * @throws Error if workflow is invalid or missing required nodes
+   */
+  constructor(workflow, nodeModels, services) {
+    __privateAdd(this, _WorkflowModel_instances);
+    /** Array of instantiated node models for this workflow */
+    this.nodes = [];
+    /** Array of edge models connecting the nodes */
+    this.edges = [];
+    /** The node currently waiting for events (null before start or after completion) */
+    this.currentNode = null;
+    /** Execution history recording workflow transitions */
+    this.history = [];
+    /** Current execution status of the workflow */
+    this.status = WorkflowStatus.Idle;
+    /** Unique identifier for this workflow instance */
+    this.instanceId = "";
+    /** Unix timestamp (ms) when this workflow instance was started */
+    this.startedAt = 0;
+    const ajv = new Ajv();
+    const validate = ajv.compile(WorkflowSchema);
+    if (!validate(workflow)) {
+      throw new Error(
+        "Invalid workflow data: " + ajv.errorsText(validate.errors)
+      );
+    }
+    this.workflow = workflow;
+    function nodeHasType(node) {
+      return node.type !== void 0;
+    }
+    this.nodes = this.workflow.flow.nodes.filter(nodeHasType).map((node) => {
+      const model = nodeModels[node.type];
+      if (!model) {
+        throw new Error(`Node type ${node.type} not found`);
+      }
+      const instance = model.create(node);
+      if (services) {
+        instance.services = services;
+      }
+      return instance;
+    });
+    this.edges = this.workflow.flow.edges.map((e) => {
+      const edge = new EdgeModel_default(e);
+      const sourceNode = this.getNode(edge.getSourceNodeId());
+      if (!sourceNode) {
+        throw new Error(`Source node ${edge.getSourceNodeId()} not found`);
+      }
+      const targetNode = this.getNode(edge.getTargetNodeId());
+      if (!targetNode) {
+        throw new Error(`Target node ${edge.getTargetNodeId()} not found`);
+      }
+      sourceNode.connect(targetNode, edge);
+      return edge;
+    });
+    if (!this.getStartNode()) {
+      throw new Error("Workflow does not have a start node");
+    }
+  }
+  // PUBLIC METHODS
+  /**
+   * Restores workflow state from a previously saved context.
+   * Use this to resume a workflow that was interrupted or to restore from persistence.
+   * After calling setContext, you must call start() to begin processing events.
+   * @param context - The context to restore from
+   * @throws Error if workflow is already running
+   * @throws Error if context is invalid or doesn't match this workflow
+   * @throws Error if the current node in context doesn't exist in the workflow
+   */
+  setContext(context) {
+    if (this.status !== WorkflowStatus.Idle) {
+      throw new Error("Workflow is already running");
+    }
+    const ajv = new Ajv();
+    const validate = ajv.compile(ContextSchema);
+    if (!validate(context)) {
+      throw new Error(
+        "Invalid context data: " + ajv.errorsText(validate.errors)
+      );
+    }
+    if (this.workflow.id !== context.workflowId) {
+      throw new Error("Workflow id does not match");
+    }
+    this.currentNode = this.getNode(context.currentNodeId);
+    if (!this.currentNode) {
+      throw new Error("Current node does not exist in workflow");
+    }
+    this.nodes.forEach((node) => {
+      node.setState(context.nodeState[node.getId()] || {});
+    });
+    this.history = context.history || [];
+    this.instanceId = context.instanceId;
+    this.startedAt = context.startedAt;
+    if (context.isCompleted) {
+      this.status = WorkflowStatus.Completed;
+    }
+  }
+  /**
+   * Exports the current workflow state as a Context object.
+   * The context contains all information needed to restore the workflow later.
+   * @returns A Context object containing workflow state
+   */
+  getContext() {
+    return {
+      workflowId: this.workflow.id,
+      instanceId: this.instanceId,
+      currentNodeId: this.currentNode && this.currentNode.getId(),
+      nodeState: this.nodes.reduce((acc, node) => {
+        acc[node.getId()] = node.getState();
+        return acc;
+      }, {}),
+      history: this.history,
+      isCompleted: this.status === WorkflowStatus.Completed,
+      startedAt: this.startedAt
+    };
+  }
+  /**
+   * Gets the current execution status of the workflow.
+   * @returns The current WorkflowStatus
+   */
+  getStatus() {
+    return this.status;
+  }
+  /**
+   * Starts or resumes the workflow execution.
+   * If no context was set, starts from the beginning at the start node.
+   * If a context was set via setContext(), resumes from the saved position.
+   * @throws Error if workflow is already running or completed
+   * @throws Error if workflow has no start node
+   */
+  start() {
+    if (this.status === WorkflowStatus.Completed) {
+      throw new Error("Workflow is already completed");
+    }
+    if (this.status !== WorkflowStatus.Idle) {
+      throw new Error("Workflow is already running");
+    }
+    if (!this.currentNode) {
+      this.currentNode = this.getStartNode();
+      if (this.instanceId === "") {
+        this.instanceId = `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+      }
+      if (this.startedAt === 0) {
+        this.startedAt = Date.now();
+      }
+    }
+    if (!this.currentNode) {
+      throw new Error("Workflow does not have a start node");
+    }
+    this.status = WorkflowStatus.Waiting;
+  }
+  /**
+   * Processes an incoming event through the workflow.
+   *
+   * This is the main event processing method. It passes the event to the current node
+   * and handles workflow transitions. The method recursively processes the event through
+   * subsequent nodes until a node doesn't accept the event or the workflow completes.
+   *
+   * @param event - The event to process
+   * @throws Error if workflow is not in waiting status
+   * @throws Error if event is invalid
+   * @throws Error if current node is not set
+   */
+  async acceptEvent(event) {
+    if (this.status != WorkflowStatus.Waiting) {
+      throw new Error(
+        `Workflow cannot accept events in current status: ${this.status}`
+      );
+    }
+    const ajv = new Ajv();
+    const validate = ajv.compile(EventSchema);
+    if (!validate(event)) {
+      throw new Error("Invalid event data: " + ajv.errorsText(validate.errors));
+    }
+    const currentNode = this.getCurrentNode();
+    if (!currentNode) {
+      throw new Error("Current node not set");
+    }
+    const processed = await currentNode.acceptEvent(event);
+    if (!processed) {
+      this.status = WorkflowStatus.Waiting;
+      return;
+    }
+    this.status = WorkflowStatus.Processing;
+    const nextNode = await currentNode.nextNode(event);
+    if (currentNode.equals(nextNode)) {
+      this.status = WorkflowStatus.Waiting;
+      return;
+    }
+    if (currentNode.equals(this.getStartNode())) {
+      __privateMethod(this, _WorkflowModel_instances, startWorkflow_fn).call(this, event);
+    }
+    if (!nextNode) {
+      __privateMethod(this, _WorkflowModel_instances, completeWorkflow_fn).call(this, event);
+      return;
+    }
+    this.status = WorkflowStatus.Transforming;
+    __privateMethod(this, _WorkflowModel_instances, moveToNode_fn).call(this, nextNode, event);
+    this.status = WorkflowStatus.Waiting;
+    return await this.acceptEvent(event);
+  }
+  // HELPER METHODS
+  /**
+   * Gets the current node that is waiting for events.
+   * @returns The current NodeModel
+   * @throws Error if workflow is not running (still idle)
+   */
+  getCurrentNode() {
+    if (this.status === WorkflowStatus.Idle) {
+      throw new Error("Workflow is not running");
+    }
+    return this.currentNode;
+  }
+  /**
+   * Finds the start node of the workflow.
+   * The start node is the node with no incoming edges.
+   * @returns The start NodeModel, or null if not found
+   */
+  getStartNode() {
+    const startNode = this.nodes.find((node) => {
+      return !this.edges.some(
+        (edge) => String(edge.getTargetNodeId()) === String(node.getId())
+      );
+    });
+    return startNode || null;
+  }
+  /**
+   * Finds a node by its ID.
+   * @param nodeId - The ID of the node to find (can be null)
+   * @returns The NodeModel if found, or null if not found or nodeId is null
+   */
+  getNode(nodeId) {
+    if (!nodeId) {
+      return null;
+    }
+    const findNode = this.nodes.find(
+      (node) => String(node.getId()) === String(nodeId)
+    );
+    return findNode || null;
+  }
+};
+_WorkflowModel_instances = new WeakSet();
+// PRIVATE METHODS
+/**
+ * Records workflow start in history.
+ * Called when the workflow transitions from the start node.
+ * @param _event - The triggering event (unused, kept for consistency)
+ */
+startWorkflow_fn = function(_event) {
+  this.history.push({
+    time: Date.now(),
+    type: "started",
+    fromNodeId: null,
+    toNodeId: this.currentNode && this.currentNode.getId()
+  });
+  __privateMethod(this, _WorkflowModel_instances, log_fn).call(this);
+};
+/**
+ * Moves the workflow to a new node and records the transition.
+ * @param nextNode - The node to move to
+ * @param _event - The triggering event (unused, kept for consistency)
+ */
+moveToNode_fn = function(nextNode, _event) {
+  this.history.push({
+    time: Date.now(),
+    type: "step",
+    fromNodeId: this.currentNode && this.currentNode.getId(),
+    toNodeId: nextNode.getId()
+  });
+  this.currentNode = nextNode;
+  __privateMethod(this, _WorkflowModel_instances, log_fn).call(this);
+};
+/**
+ * Marks the workflow as completed and records the completion.
+ * @param _event - The triggering event (unused, kept for consistency)
+ */
+completeWorkflow_fn = function(_event) {
+  this.history.push({
+    time: Date.now(),
+    type: "completed",
+    fromNodeId: this.currentNode && this.currentNode.getId(),
+    toNodeId: null
+  });
+  this.status = WorkflowStatus.Completed;
+  __privateMethod(this, _WorkflowModel_instances, log_fn).call(this);
+};
+/**
+ * Internal logging helper for debugging workflow transitions.
+ */
+log_fn = function() {
+};
+var WorkflowModel_default = WorkflowModel;
+
+// src/engine/NodeModel.ts
+var NodeModel = class _NodeModel {
+  /**
+   * Creates a new NodeModel instance.
+   * @param node - The node definition from the workflow
+   * @throws Error if node is missing or doesn't have an id
+   */
+  constructor(node) {
+    /** Services available to nodes (scheduler, etc.) */
+    this.services = {};
+    if (!node || !node.id) {
+      throw new Error("Node must have an id");
+    }
+    this.node = node;
+    this.connections = [];
+    this.state = {};
+  }
+  /**
+   * Factory method to create a new NodeModel instance.
+   * Subclasses should override this method to perform type validation.
+   * @param node - The node definition from the workflow
+   * @returns A new NodeModel instance
+   */
+  static create(node) {
+    return new this(node);
+  }
+  /**
+   * Gets the unique identifier of this node.
+   * @returns The node's ID as a string
+   */
+  getId() {
+    return String(this.node.id);
+  }
+  /**
+   * Gets the data payload associated with this node.
+   * This typically contains node-specific configuration like parameters.
+   * @returns The node's data object, or an empty object if not defined
+   */
+  getData() {
+    return this.node.data || {};
+  }
+  /**
+   * Checks if this node is equal to another node by comparing IDs.
+   * @param node - The node to compare against (can be null)
+   * @returns True if the nodes have the same ID, false otherwise
+   */
+  equals(node) {
+    if (!node) {
+      return false;
+    }
+    if (node instanceof _NodeModel) {
+      return this.getId() === node.getId();
+    }
+    return false;
+  }
+  /**
+   * Gets the current internal state of the node.
+   * State is used to share data between `acceptEvent` and `nextNode` methods.
+   * @returns The current state object
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Replaces the entire internal state of the node.
+   * @param state - The new state object
+   */
+  setState(state) {
+    this.state = state;
+  }
+  /**
+   * Merges changes into the existing state (shallow merge).
+   * @param changes - Object containing state properties to update
+   */
+  updateState(changes) {
+    this.state = {
+      ...this.state,
+      ...changes
+    };
+  }
+  /**
+   * Connects this node to a target node via an edge.
+   * This node becomes the source node of the connection.
+   * @param targetNode - The node to connect to
+   * @param edge - The edge defining the connection
+   * @throws Error if attempting to connect node to itself
+   * @throws Error if connection already exists with the same source handle
+   */
+  connect(targetNode, edge) {
+    if (this.getId() === targetNode.getId()) {
+      throw new Error("Cannot connect node to itself");
+    }
+    const sameConnection = this.connections.find(
+      (c) => c.targetNode.getId() === targetNode.getId()
+    );
+    if (sameConnection) {
+      const prevEdge = sameConnection.edge;
+      if (prevEdge.getSourceHandle() === edge.getSourceHandle()) {
+        throw new Error("Connection already exists");
+      }
+    }
+    this.connections.push({
+      targetNode,
+      edge
+    });
+  }
+  /**
+   * Returns all outgoing connections from this node.
+   * @returns Array of Connection objects containing targetNode and edge
+   */
+  getConnections() {
+    return this.connections;
+  }
+  /**
+   * Returns all source handle identifiers (output labels) for this node.
+   * Source handles define the different output paths from this node.
+   * @returns Array of source handle strings
+   */
+  getSourceHandles() {
+    return this.connections.map((c) => c.edge.getSourceHandle());
+  }
+  /**
+   * Finds the target node connected to a specific source handle.
+   * @param sourceHandle - The source handle (output) identifier to look up
+   * @returns The connected NodeModel, or null if no connection exists for the handle
+   */
+  getTargetNodeFromSourceHandle(sourceHandle) {
+    const connection = this.connections.find(
+      (c) => c.edge.getSourceHandle() === sourceHandle
+    );
+    if (connection) {
+      return connection.targetNode;
+    }
+    return null;
+  }
+  /**
+   * Returns the target node connected to the first source handle, or null
+   * if this node has no outgoing connections.
+   *
+   * Most pass-through nodes (single output) implement `nextNode` as
+   * `return this.getDefaultNext();`. Use it instead of repeating the
+   * `getSourceHandles()[0]` lookup by hand.
+   */
+  getDefaultNext() {
+    const handle = this.getSourceHandles()[0];
+    if (!handle) {
+      return null;
+    }
+    return this.getTargetNodeFromSourceHandle(handle);
+  }
+  /**
+   * Accepts and processes an incoming event.
+   *
+   * This method must be overridden by subclasses to define how the node
+   * handles events. The method can be called multiple times for the same
+   * logical operation (e.g., start wait, then complete wait).
+   *
+   * @param event - The event to process
+   * @returns Promise resolving to true if event is accepted and processing is complete,
+   *          false if the node is still waiting or doesn't accept the event
+   * @throws Error if not implemented by subclass
+   */
+  async acceptEvent(_event) {
+    throw new Error("acceptEvent method not implemented");
+  }
+  /**
+   * Determines the next node to execute after processing an event.
+   *
+   * This method must be overridden by subclasses. It is called after
+   * `acceptEvent` returns true to determine where the workflow should go next.
+   *
+   * @param event - The event that was processed
+   * @returns Promise resolving to the next NodeModel to execute,
+   *          or null if the workflow should end
+   * @throws Error if not implemented by subclass
+   */
+  async nextNode(_event) {
+    throw new Error("nextNode method not implemented");
+  }
+};
+var NodeModel_default = NodeModel;
+
+// src/nodes/ActionModel.ts
+var ActionModel = class extends NodeModel_default {
+  /**
+   * Creates a new ActionModel instance.
+   * @param node - The node definition from the workflow
+   */
+  constructor(node) {
+    super(node);
+  }
+  /**
+   * Factory method to create an ActionModel with type validation.
+   * @param node - The node definition from the workflow
+   * @returns A new ActionModel instance
+   * @throws Error if node type is not "Action"
+   */
+  static create(node) {
+    if (node.type !== "Action") {
+      throw new Error("Node type must be Action");
+    }
+    return new this(node);
+  }
+  /**
+   * Accepts all events immediately.
+   * Actions don't filter events - they execute whenever reached.
+   * @param _event - The event being processed (unused)
+   * @returns Always returns true (event accepted)
+   */
+  async acceptEvent(_event) {
+    return true;
+  }
+  /**
+   * Returns the next node connected to this action's output.
+   * @param _event - The event being processed (unused)
+   * @returns The next NodeModel, or null if no connection exists
+   */
+  async nextNode(_event) {
+    return this.getDefaultNext();
+  }
+};
+
+// src/nodes/conditionEvaluator.ts
+function evaluateConditions(conditions, facts) {
+  if (!conditions || !Array.isArray(conditions.groups)) return false;
+  return conditions.groups.some((group) => evaluateGroup(group, facts));
+}
+function evaluateGroup(group, facts) {
+  const rules = group.conditions ?? [];
+  if (group.operator === "all") {
+    return rules.every((rule) => evaluateRule(rule, facts));
+  }
+  return rules.some((rule) => evaluateRule(rule, facts));
+}
+function evaluateRule(rule, facts) {
+  const factValue = resolvePath(facts, rule.fact);
+  return applyOperator(rule.operator, factValue, rule.value);
+}
+function resolvePath(source, path) {
+  if (!path) return void 0;
+  const parts = path.split(".");
+  let current = source;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function applyOperator(operator, factValue, ruleValue) {
+  switch (operator) {
+    case "equal":
+      return factValue === ruleValue;
+    case "notEqual":
+      return factValue !== ruleValue;
+    case "greaterThan":
+      return isNumber(factValue) && isNumber(ruleValue) && factValue > ruleValue;
+    case "greaterThanInclusive":
+      return isNumber(factValue) && isNumber(ruleValue) && factValue >= ruleValue;
+    case "lessThan":
+      return isNumber(factValue) && isNumber(ruleValue) && factValue < ruleValue;
+    case "lessThanInclusive":
+      return isNumber(factValue) && isNumber(ruleValue) && factValue <= ruleValue;
+    case "in":
+      return Array.isArray(ruleValue) && ruleValue.includes(factValue);
+    case "notIn":
+      return Array.isArray(ruleValue) && !ruleValue.includes(factValue);
+    case "contains":
+      if (Array.isArray(factValue)) return factValue.includes(ruleValue);
+      if (typeof factValue === "string" && typeof ruleValue === "string") {
+        return factValue.includes(ruleValue);
+      }
+      return false;
+    case "doesNotContain":
+      if (Array.isArray(factValue)) return !factValue.includes(ruleValue);
+      if (typeof factValue === "string" && typeof ruleValue === "string") {
+        return !factValue.includes(ruleValue);
+      }
+      return false;
+    default:
+      return false;
+  }
+}
+function isNumber(value) {
+  return typeof value === "number" && !Number.isNaN(value);
+}
+
+// src/nodes/ConditionModel.ts
+var ConditionModel = class extends NodeModel_default {
+  constructor(node) {
+    super(node);
+  }
+  /**
+   * Factory method to create a ConditionModel with type validation.
+   */
+  static create(node) {
+    if (node.type !== "Condition") {
+      throw new Error("Node type must be Condition");
+    }
+    return new this(node);
+  }
+  /**
+   * Evaluates the condition against the event data using the built-in
+   * evaluator. The result is stored in state for use by nextNode().
+   */
+  async acceptEvent(event) {
+    const conditions = this.getData().conditions;
+    const facts = event.data ?? {};
+    const conditionResult = evaluateConditions(conditions, facts);
+    this.setState({ conditionResult });
+    return true;
+  }
+  /**
+   * Routes to "true" handle if condition passed, "false" handle otherwise.
+   */
+  async nextNode(_event) {
+    const conditionTrue = this.getState().conditionResult;
+    if (conditionTrue) {
+      return this.getTargetNodeFromSourceHandle("true");
+    } else {
+      return this.getTargetNodeFromSourceHandle("false");
+    }
+  }
+};
+
+// src/nodes/ExitModel.ts
+var ExitModel = class extends NodeModel_default {
+  /**
+   * Creates a new ExitModel instance.
+   * @param node - The node definition from the workflow
+   */
+  constructor(node) {
+    super(node);
+  }
+  /**
+   * Factory method to create an ExitModel with type validation.
+   * @param node - The node definition from the workflow
+   * @returns A new ExitModel instance
+   * @throws Error if node type is not "Exit"
+   */
+  static create(node) {
+    if (node.type !== "Exit") {
+      throw new Error("Node type must be Exit");
+    }
+    return new this(node);
+  }
+  /**
+   * Accepts all events immediately.
+   * Exit nodes don't filter events - they terminate whenever reached.
+   * @param _event - The event being processed (unused)
+   * @returns Always returns true (event accepted)
+   */
+  async acceptEvent(_event) {
+    return true;
+  }
+  /**
+   * Always returns null to signal workflow termination.
+   * @param _event - The event being processed (unused)
+   * @returns Always null, signaling workflow completion
+   */
+  async nextNode(_event) {
+    return null;
+  }
+};
+
+// src/nodes/TriggerModel.ts
+var TriggerModel = class extends NodeModel_default {
+  /**
+   * Creates a new TriggerModel instance.
+   * @param node - The node definition from the workflow
+   */
+  constructor(node) {
+    super(node);
+  }
+  /**
+   * Factory method to create a TriggerModel with type validation.
+   * @param node - The node definition from the workflow
+   * @returns A new TriggerModel instance
+   * @throws Error if node type is not "Trigger"
+   */
+  static create(node) {
+    if (node.type !== "Trigger") {
+      throw new Error("Node type must be Trigger");
+    }
+    return new this(node);
+  }
+  /**
+   * Accepts events that match the configured trigger event type.
+   * @param event - The event being processed
+   * @returns True if event.type matches the configured params.event, false otherwise
+   */
+  async acceptEvent(event) {
+    const nodeData = this.getData();
+    return event.type === nodeData.params.event;
+  }
+  /**
+   * Returns the next node connected to this trigger's output.
+   * @param _event - The event being processed (unused)
+   * @returns The next NodeModel, or null if no connection exists
+   */
+  async nextNode(_event) {
+    return this.getDefaultNext();
+  }
+};
+
+// src/nodes/WaitModel.ts
+var WaitModel = class extends NodeModel_default {
+  /**
+   * Creates a new WaitModel instance.
+   * @param node - The node definition from the workflow
+   */
+  constructor(node) {
+    super(node);
+  }
+  /**
+   * Factory method to create a WaitModel with type validation.
+   * @param node - The node definition from the workflow
+   * @returns A new WaitModel instance
+   * @throws Error if node type is not "Wait"
+   */
+  static create(node) {
+    if (node.type !== "Wait") {
+      throw new Error("Node type must be of type Wait");
+    }
+    return new this(node);
+  }
+  /**
+   * Checks if the node is currently in a waiting state.
+   * @returns True if waiting has been started but not completed
+   */
+  isWaiting() {
+    const state = this.getState();
+    return state && state.waitStartsAt !== void 0;
+  }
+  /**
+   * Starts the waiting period by recording the start time and scheduling a timeout event.
+   * @param time - The timestamp when waiting begins (usually event.time)
+   * @param eventData - Optional event data to include in the scheduled timeout (for routing)
+   */
+  async startWaiting(time, eventData) {
+    this.updateState({ waitStartsAt: time });
+    if (this.services.scheduler) {
+      const duration = this.getData().params.duration || 0;
+      const timeoutEvent = {
+        id: `timeout_${this.getId()}_${Date.now()}`,
+        type: "system:timeout",
+        time: time + duration,
+        data: eventData
+      };
+      await this.services.scheduler.schedule(timeoutEvent, duration);
+    }
+  }
+  /**
+   * Stops the waiting period by recording the end time.
+   * @param time - The timestamp when waiting ends
+   */
+  stopWaiting(time) {
+    this.updateState({ waitEndsAt: time });
+  }
+  /**
+   * Checks if the configured wait duration has elapsed.
+   * @param currentTime - The current timestamp to check against
+   * @returns True if waiting and the duration has passed, false otherwise
+   */
+  isWaitComplete(currentTime) {
+    if (this.isWaiting()) {
+      const state = this.getState();
+      const nodeData = this.getData();
+      const waitDuration = nodeData.params.duration || 0;
+      return currentTime >= state.waitStartsAt + waitDuration;
+    }
+    return false;
+  }
+  /**
+   * Processes events during the waiting period.
+   * - First event: Starts waiting and returns false
+   * - Subsequent events: Checks if wait is complete
+   *   - If complete: Stops waiting and returns true
+   *   - If not complete: Returns false (still waiting)
+   * @param event - The event being processed
+   * @returns True if wait is complete and event is accepted, false if still waiting
+   */
+  async acceptEvent(event) {
+    if (this.isWaiting()) {
+      if (this.isWaitComplete(event.time)) {
+        this.stopWaiting(event.time);
+        return true;
+      }
+      return false;
+    } else {
+      await this.startWaiting(event.time, event.data);
+      return false;
+    }
+  }
+  /**
+   * Returns the next node connected to this wait node's output.
+   * @param _event - The event being processed (unused)
+   * @returns The next NodeModel, or null if no connection exists
+   */
+  async nextNode(_event) {
+    return this.getDefaultNext();
+  }
+};
+
+// src/nodes/TriggerOrTimeout.ts
+var TriggerOrTimeoutModel = class extends WaitModel {
+  /**
+   * Creates a new TriggerOrTimeoutModel instance.
+   * @param node - The node definition from the workflow
+   */
+  constructor(node) {
+    super(node);
+  }
+  /**
+   * Factory method to create a TriggerOrTimeoutModel with type validation.
+   * @param node - The node definition from the workflow
+   * @returns A new TriggerOrTimeoutModel instance
+   * @throws Error if node type is not "TriggerOrTimeout"
+   */
+  static create(node) {
+    if (node.type !== "TriggerOrTimeout") {
+      throw new Error("Node type must be TriggerOrTimeout");
+    }
+    return new this(node);
+  }
+  /**
+   * Processes events, accepting either a matching trigger event or timeout completion.
+   * - If event type matches params.event: Records `resolvedBy: "trigger"` and accepts
+   * - If already waiting and timeout elapsed: Records `resolvedBy: "timeout"` and accepts
+   * - If not waiting: Starts waiting and returns false
+   * @param event - The event being processed
+   * @returns True if event matches trigger or timeout completed, false if still waiting
+   */
+  async acceptEvent(event) {
+    const nodeData = this.getData();
+    if (event.type === nodeData.params.event) {
+      this.stopWaiting(event.time);
+      this.updateState({ resolvedBy: "trigger" });
+      return true;
+    } else if (this.isWaiting()) {
+      if (this.isWaitComplete(event.time)) {
+        this.stopWaiting(event.time);
+        this.updateState({ resolvedBy: "timeout" });
+        return true;
+      }
+      return false;
+    } else {
+      await this.startWaiting(event.time, event.data);
+      return false;
+    }
+  }
+  /**
+   * Routes execution to the `trigger` source handle if the matching event
+   * resolved the wait, or the `timeout` source handle if the duration elapsed.
+   * @param _event - The event being processed (unused)
+   * @returns The next NodeModel, or null if no connection exists for the resolved handle
+   */
+  async nextNode(_event) {
+    const { resolvedBy } = this.getState();
+    return this.getTargetNodeFromSourceHandle(resolvedBy);
+  }
+};
+
+// src/nodes/index.ts
+var nodes_default = {
+  Action: ActionModel,
+  Condition: ConditionModel,
+  Exit: ExitModel,
+  Trigger: TriggerModel,
+  Wait: WaitModel,
+  TriggerOrTimeout: TriggerOrTimeoutModel
+};
+
+// src/manager/WorkflowManager.ts
+import { WorkflowStatus as WorkflowStatus2 } from "@omega-flow/types";
+var WorkflowManager = class {
+  /**
+   * Creates a new WorkflowManager instance.
+   * @param config - Configuration options including storage backends and node models
+   */
+  constructor(config) {
+    this.workflowStore = config.workflowStore;
+    this.workflowMemory = config.workflowMemory;
+    this.workflowScheduler = config.workflowScheduler;
+    this.nodeModels = config.nodeModels;
+    this.eventExtractor = config.eventExtractor;
+  }
+  /**
+   * Process an event by routing it to appropriate workflow instances
+   * @param event - The event to process
+   */
+  async processEvent(event) {
+    const [domain, subjectId] = this.eventExtractor(event);
+    const workflows = await this.workflowStore.getAllWorkflows(domain);
+    for (const workflowDef of workflows) {
+      try {
+        await this.processWorkflowForEvent(
+          workflowDef,
+          event,
+          domain,
+          subjectId
+        );
+      } catch (error) {
+        console.error(
+          `Error processing workflow ${workflowDef.id} for domain ${domain}, subject ${subjectId}:`,
+          error
+        );
+      }
+    }
+  }
+  /**
+   * Process a specific workflow definition for an event
+   * @param workflowDef - The workflow definition
+   * @param event - The event to process
+   * @param domain - The domain identifier
+   * @param subjectId - The subject ID extracted from the event
+   */
+  async processWorkflowForEvent(workflowDef, event, domain, subjectId) {
+    const contexts = await this.workflowMemory.getContexts(
+      domain,
+      workflowDef.id,
+      subjectId
+    );
+    const activeContexts = contexts.filter((ctx) => !ctx.isCompleted);
+    const completedContexts = contexts.filter((ctx) => ctx.isCompleted);
+    for (const context of activeContexts) {
+      await this.resumeWorkflowInstance(
+        workflowDef,
+        context,
+        event,
+        domain,
+        subjectId
+      );
+    }
+    const canStartNew = this.canStartNewInstance(
+      workflowDef,
+      activeContexts,
+      completedContexts
+    );
+    if (canStartNew) {
+      await this.tryStartNewWorkflowInstance(
+        workflowDef,
+        event,
+        domain,
+        subjectId
+      );
+    }
+  }
+  /**
+   * Check if a new workflow instance can be started based on frequency option
+   * @param workflowDef - The workflow definition
+   * @param activeContexts - Currently active workflow instances
+   * @param completedContexts - Completed workflow instances
+   * @returns true if a new instance can be started
+   */
+  canStartNewInstance(workflowDef, activeContexts, completedContexts) {
+    const frequency = workflowDef.options.frequency;
+    if (!frequency) {
+      return activeContexts.length === 0 && completedContexts.length === 0;
+    }
+    if (frequency.type === "one_time") {
+      return activeContexts.length === 0 && completedContexts.length === 0;
+    }
+    if (frequency.type === "every_rematch") {
+      if (activeContexts.length > 0) {
+        return false;
+      }
+      if (frequency.interval && completedContexts.length > 0) {
+        const mostRecentCompleted = completedContexts.reduce(
+          (latest, ctx) => ctx.startedAt > latest.startedAt ? ctx : latest
+        );
+        const intervalMs = frequency.interval * 1e3;
+        const timeSinceLastStart = Date.now() - mostRecentCompleted.startedAt;
+        return timeSinceLastStart >= intervalMs;
+      }
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Try to start a new workflow instance for a subject
+   * Only saves context if the workflow actually started (start node accepted the event)
+   * @param workflowDef - The workflow definition
+   * @param event - The triggering event
+   * @param domain - The domain identifier
+   * @param subjectId - The subject ID
+   */
+  async tryStartNewWorkflowInstance(workflowDef, event, domain, subjectId) {
+    const workflow = new WorkflowModel_default(workflowDef, this.nodeModels, { scheduler: this.workflowScheduler });
+    workflow.start();
+    const startNode = workflow.getStartNode();
+    try {
+      await workflow.acceptEvent(event);
+    } catch (error) {
+      console.error(
+        `Error accepting event in workflow ${workflowDef.id}:`,
+        error
+      );
+      throw error;
+    }
+    if (workflow.getStatus() === WorkflowStatus2.Waiting && workflow.getCurrentNode()?.equals(startNode)) {
+      return;
+    }
+    const context = workflow.getContext();
+    await this.workflowMemory.saveContext(
+      domain,
+      workflowDef.id,
+      subjectId,
+      context
+    );
+  }
+  /**
+   * Resume an existing workflow instance and process an event
+   * @param workflowDef - The workflow definition
+   * @param context - The existing context
+   * @param event - The event to process
+   * @param domain - The domain identifier
+   * @param subjectId - The subject ID
+   */
+  async resumeWorkflowInstance(workflowDef, context, event, domain, subjectId) {
+    const workflow = new WorkflowModel_default(workflowDef, this.nodeModels, { scheduler: this.workflowScheduler });
+    workflow.setContext(context);
+    workflow.start();
+    try {
+      await workflow.acceptEvent(event);
+    } catch (error) {
+      console.error(
+        `Error accepting event in workflow ${workflowDef.id}:`,
+        error
+      );
+      throw error;
+    }
+    const updatedContext = workflow.getContext();
+    await this.workflowMemory.saveContext(
+      domain,
+      workflowDef.id,
+      subjectId,
+      updatedContext
+    );
+  }
+  /**
+   * Get the workflow scheduler instance
+   * Useful for nodes that need to schedule future events
+   * @returns The workflow scheduler
+   */
+  getScheduler() {
+    return this.workflowScheduler;
+  }
+};
+
+// src/manager/stores/InMemoryWorkflowStore.ts
+var InMemoryWorkflowStore = class {
+  /**
+   * Creates a new InMemoryWorkflowStore.
+   * @param workflows - Optional array of workflows to initialize the store with
+   */
+  constructor(workflows = []) {
+    this.workflows = /* @__PURE__ */ new Map();
+    for (const { domain, workflow } of workflows) {
+      let domainWorkflows = this.workflows.get(domain);
+      if (!domainWorkflows) {
+        domainWorkflows = /* @__PURE__ */ new Map();
+        this.workflows.set(domain, domainWorkflows);
+      }
+      domainWorkflows.set(workflow.id, workflow);
+    }
+  }
+  /**
+   * Retrieve a workflow definition by its ID
+   * @param domain - The domain identifier
+   * @param workflowId - The unique identifier of the workflow
+   * @returns Promise resolving to the workflow definition, or null if not found
+   */
+  async getWorkflow(domain, workflowId) {
+    const domainWorkflows = this.workflows.get(domain);
+    return domainWorkflows?.get(workflowId) ?? null;
+  }
+  /**
+   * Add or update a workflow definition in the store
+   * @param domain - The domain identifier
+   * @param workflow - The workflow definition to add or update
+   */
+  async setWorkflow(domain, workflow) {
+    let domainWorkflows = this.workflows.get(domain);
+    if (!domainWorkflows) {
+      domainWorkflows = /* @__PURE__ */ new Map();
+      this.workflows.set(domain, domainWorkflows);
+    }
+    domainWorkflows.set(workflow.id, workflow);
+  }
+  /**
+   * Remove a workflow definition from the store
+   * @param domain - The domain identifier
+   * @param workflowId - The unique identifier of the workflow to remove
+   */
+  async deleteWorkflow(domain, workflowId) {
+    const domainWorkflows = this.workflows.get(domain);
+    if (domainWorkflows) {
+      domainWorkflows.delete(workflowId);
+      if (domainWorkflows.size === 0) {
+        this.workflows.delete(domain);
+      }
+    }
+  }
+  /**
+   * Get all workflow definitions in the store for a specific domain
+   * @param domain - The domain identifier
+   * @returns Promise resolving to an array of all workflows in the domain
+   */
+  async getAllWorkflows(domain) {
+    const domainWorkflows = this.workflows.get(domain);
+    if (!domainWorkflows) {
+      return [];
+    }
+    return Array.from(domainWorkflows.values());
+  }
+};
+
+// src/manager/memories/InMemoryWorkflowMemory.ts
+var InMemoryWorkflowMemory = class {
+  /**
+   * Creates a new InMemoryWorkflowMemory with empty storage.
+   */
+  constructor() {
+    this.contexts = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Retrieve all workflow contexts for a specific subject in a domain
+   * @param domain - The domain identifier
+   * @param workflowId - The unique identifier of the workflow
+   * @param subjectId - The unique identifier of the subject
+   * @returns Promise resolving to an array of contexts
+   */
+  async getContexts(domain, workflowId, subjectId) {
+    const domainContexts = this.contexts.get(domain);
+    if (!domainContexts) {
+      return [];
+    }
+    const workflowContexts = domainContexts.get(workflowId);
+    if (!workflowContexts) {
+      return [];
+    }
+    const subjectContexts = workflowContexts.get(subjectId);
+    if (!subjectContexts) {
+      return [];
+    }
+    return Array.from(subjectContexts.values());
+  }
+  /**
+   * Save workflow context for a specific subject in a domain
+   * @param domain - The domain identifier
+   * @param workflowId - The unique identifier of the workflow
+   * @param subjectId - The unique identifier of the subject
+   * @param context - The context to save (identified by context.instanceId)
+   */
+  async saveContext(domain, workflowId, subjectId, context) {
+    let domainContexts = this.contexts.get(domain);
+    if (!domainContexts) {
+      domainContexts = /* @__PURE__ */ new Map();
+      this.contexts.set(domain, domainContexts);
+    }
+    let workflowContexts = domainContexts.get(workflowId);
+    if (!workflowContexts) {
+      workflowContexts = /* @__PURE__ */ new Map();
+      domainContexts.set(workflowId, workflowContexts);
+    }
+    let subjectContexts = workflowContexts.get(subjectId);
+    if (!subjectContexts) {
+      subjectContexts = /* @__PURE__ */ new Map();
+      workflowContexts.set(subjectId, subjectContexts);
+    }
+    subjectContexts.set(context.instanceId, context);
+  }
+  /**
+   * Delete workflow context for a specific subject and instance in a domain
+   * @param domain - The domain identifier
+   * @param workflowId - The unique identifier of the workflow
+   * @param subjectId - The unique identifier of the subject
+   * @param instanceId - The unique identifier of the workflow instance
+   */
+  async deleteContext(domain, workflowId, subjectId, instanceId) {
+    const domainContexts = this.contexts.get(domain);
+    if (!domainContexts) {
+      return;
+    }
+    const workflowContexts = domainContexts.get(workflowId);
+    if (!workflowContexts) {
+      return;
+    }
+    const subjectContexts = workflowContexts.get(subjectId);
+    if (!subjectContexts) {
+      return;
+    }
+    subjectContexts.delete(instanceId);
+    if (subjectContexts.size === 0) {
+      workflowContexts.delete(subjectId);
+    }
+    if (workflowContexts.size === 0) {
+      domainContexts.delete(workflowId);
+    }
+    if (domainContexts.size === 0) {
+      this.contexts.delete(domain);
+    }
+  }
+  /**
+   * Clear all contexts from memory
+   */
+  async clear() {
+    this.contexts.clear();
+  }
+};
+
+// src/manager/schedulers/InMemoryWorkflowScheduler.ts
+var InMemoryWorkflowScheduler = class {
+  /**
+   * Creates a new InMemoryWorkflowScheduler.
+   * Call setWorkflowManager() before scheduling any events.
+   */
+  constructor() {
+    this.schedules = /* @__PURE__ */ new Map();
+    this.scheduleIdCounter = 0;
+    this.workflowManager = null;
+  }
+  /**
+   * Set the workflow manager reference
+   * The scheduler will call processEvent on the manager when scheduled events are due
+   * @param manager - The workflow manager instance
+   */
+  setWorkflowManager(manager) {
+    this.workflowManager = manager;
+  }
+  /**
+   * Schedule an event to be delivered after a delay
+   * When the delay expires, the event will be passed to the workflow manager
+   * @param event - The event to schedule
+   * @param delayMs - Delay in milliseconds before the event is delivered
+   * @returns Promise resolving to a schedule ID that can be used to cancel
+   */
+  async schedule(event, delayMs) {
+    if (!this.workflowManager) {
+      throw new Error(
+        "WorkflowManager not set. Call setWorkflowManager() before scheduling events."
+      );
+    }
+    const scheduleId = `schedule_${++this.scheduleIdCounter}`;
+    const timeoutHandle = setTimeout(async () => {
+      this.schedules.delete(scheduleId);
+      if (this.workflowManager) {
+        await this.workflowManager.processEvent(event);
+      }
+    }, delayMs);
+    this.schedules.set(scheduleId, timeoutHandle);
+    return scheduleId;
+  }
+  /**
+   * Cancel a scheduled event
+   * @param scheduleId - The ID of the schedule to cancel
+   * @returns Promise resolving to true if canceled, false if not found
+   */
+  async cancel(scheduleId) {
+    const timeoutHandle = this.schedules.get(scheduleId);
+    if (!timeoutHandle) {
+      return false;
+    }
+    clearTimeout(timeoutHandle);
+    this.schedules.delete(scheduleId);
+    return true;
+  }
+  /**
+   * Get the number of currently scheduled events
+   * @returns The count of active schedules
+   */
+  getScheduleCount() {
+    return this.schedules.size;
+  }
+  /**
+   * Cancel all scheduled events
+   */
+  async cancelAll() {
+    for (const timeoutHandle of this.schedules.values()) {
+      clearTimeout(timeoutHandle);
+    }
+    this.schedules.clear();
+  }
+};
+export {
+  InMemoryWorkflowMemory,
+  InMemoryWorkflowScheduler,
+  InMemoryWorkflowStore,
+  NodeModel_default as NodeModel,
+  WorkflowManager,
+  WorkflowModel_default as WorkflowModel,
+  nodes_default as defaultNodeModels
+};