@ronaldroe/micro-flow 0.0.9

package/dist/src/enums/errors.js

@@ -0,0 +1,6 @@
+const e={INVALID_STATE_PATH:`The provided state path is invalid.
+`,INVALID_CONDITIONAL:"Conditional properties are required for LogicStep.",OBJECT_NOT_PARSEABLE:`The provided object could not be parsed.
+`,VALUE_NOT_ITERABLE:`The provided value is not iterable.
+`},t={DO_NOT_SET_STEPS_DIRECTLY:'Using this.setState("steps", ...) is not recommended. State will not be initialized correctly. Use workflow methods to manage steps instead.',BROADCAST_FAILED:`Broadcast failed or is not supported in this environment. The error has more detail:
+`};export{e as errors,t as warnings};
+//# sourceMappingURL=errors.js.map

package/dist/src/enums/errors.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/enums/errors.js"],
+  "sourcesContent": ["/**\n * Error messages used in the micro-flow library.\n * \n * @enum {string}\n * @readonly\n */\nconst errors = {\n  INVALID_STATE_PATH: 'The provided state path is invalid.\\n',\n  INVALID_CONDITIONAL: 'Conditional properties are required for LogicStep.',\n  OBJECT_NOT_PARSEABLE: 'The provided object could not be parsed.\\n',\n  VALUE_NOT_ITERABLE: 'The provided value is not iterable.\\n',\n};\n\n/**\n * Warning messages used in the micro-flow library.\n * These are typically logged to the console to alert developers of potential issues.\n * \n * @enum {string}\n * @readonly\n */\nconst warnings = {\n  DO_NOT_SET_STEPS_DIRECTLY: 'Using this.setState(\"steps\", ...) is not recommended. ' +\n    'State will not be initialized correctly. Use workflow methods to manage steps instead.',\n  BROADCAST_FAILED: 'Broadcast failed or is not supported in this environment. The error has more detail:\\n',\n};\n\nexport { errors, warnings };\n"],
+  "mappings": "AAMA,MAAMA,EAAS,CACb,mBAAoB;AAAA,EACpB,oBAAqB,qDACrB,qBAAsB;AAAA,EACtB,mBAAoB;AAAA,CACtB,EASMC,EAAW,CACf,0BAA2B,+IAE3B,iBAAkB;AAAA,CACpB",
+  "names": ["errors", "warnings"]
+}

package/dist/src/enums/flow_control_types.js

@@ -0,0 +1,2 @@
+const o={BREAK:"break",SKIP:"skip"};var t=o;export{t as default};
+//# sourceMappingURL=flow_control_types.js.map

package/dist/src/enums/flow_control_types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/enums/flow_control_types.js"],
+  "sourcesContent": ["/**\n * Enumeration of flow control types for breaking or continuing execution.\n * \n * @enum {string}\n * @readonly\n */\nconst flow_control_types = {\n  BREAK: 'break',\n  SKIP: 'skip'\n};\n\nexport default flow_control_types;\n"],
+  "mappings": "AAMA,MAAMA,EAAqB,CACzB,MAAO,QACP,KAAM,MACR,EAEA,IAAOC,EAAQD",
+  "names": ["flow_control_types", "flow_control_types_default"]
+}

package/dist/src/enums/index.js

@@ -0,0 +1,2 @@
+import{default as o}from"./conditional_step_comparators.js";import{default as a}from"./delay_types.js";export*from"./errors.js";import{default as p}from"./flow_control_types.js";import{default as _}from"./logic_step_types.js";import{default as u}from"./loop_types.js";import{default as x}from"./state_event_names.js";import{default as y}from"./step_event_names.js";import{default as c}from"./step_statuses.js";import{default as v}from"./step_types.js";import{default as k}from"./sub_step_types.js";import{default as h}from"./workflow_event_names.js";import{default as q}from"./workflow_statuses.js";import{default as A}from"./base_types.js";export{A as base_types,o as conditional_step_comparators,a as delay_types,p as flow_control_types,_ as logic_step_types,u as loop_types,x as state_event_names,y as step_event_names,c as step_statuses,v as step_types,k as sub_step_types,h as workflow_event_names,q as workflow_statuses};
+//# sourceMappingURL=index.js.map

package/dist/src/enums/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/enums/index.js"],
+  "sourcesContent": ["export { default as conditional_step_comparators } from './conditional_step_comparators.js';\nexport { default as delay_types } from './delay_types.js';\nexport * from './errors.js';\nexport { default as flow_control_types } from './flow_control_types.js';\nexport { default as logic_step_types } from './logic_step_types.js';\nexport { default as loop_types } from './loop_types.js';\nexport { default as state_event_names } from './state_event_names.js';\nexport { default as step_event_names } from './step_event_names.js';\nexport { default as step_statuses } from './step_statuses.js';\nexport { default as step_types } from './step_types.js';\nexport { default as sub_step_types } from './sub_step_types.js';\nexport { default as workflow_event_names } from './workflow_event_names.js';\nexport { default as workflow_statuses } from './workflow_statuses.js';\nexport { default as base_types } from './base_types.js';\n"],
+  "mappings": "AAAA,OAAoB,WAAXA,MAA+C,oCACxD,OAAoB,WAAXA,MAA8B,mBACvC,WAAc,cACd,OAAoB,WAAXA,MAAqC,0BAC9C,OAAoB,WAAXA,MAAmC,wBAC5C,OAAoB,WAAXA,MAA6B,kBACtC,OAAoB,WAAXA,MAAoC,yBAC7C,OAAoB,WAAXA,MAAmC,wBAC5C,OAAoB,WAAXA,MAAgC,qBACzC,OAAoB,WAAXA,MAA6B,kBACtC,OAAoB,WAAXA,MAAiC,sBAC1C,OAAoB,WAAXA,MAAuC,4BAChD,OAAoB,WAAXA,MAAoC,yBAC7C,OAAoB,WAAXA,MAA6B",
+  "names": ["default"]
+}

package/dist/src/enums/logic_step_types.js

@@ -0,0 +1,2 @@
+const o={CONDITIONAL:"conditional",LOOP:"loop",FLOW_CONTROL:"flow_control",SWITCH:"switch",SKIP:"skip"};var t=o;export{t as default};
+//# sourceMappingURL=logic_step_types.js.map

package/dist/src/enums/logic_step_types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/enums/logic_step_types.js"],
+  "sourcesContent": ["/**\n * Enumeration of logic step types for control flow operations.\n * These types define different kinds of logic-based workflow steps.\n * \n * @enum {string}\n * @readonly\n */\nconst LogicStepTypes = {\n  CONDITIONAL: 'conditional',\n  LOOP: 'loop',\n  FLOW_CONTROL: 'flow_control',\n  SWITCH: 'switch',\n  SKIP: 'skip'\n};\n\nexport default LogicStepTypes;\n"],
+  "mappings": "AAOA,MAAMA,EAAiB,CACrB,YAAa,cACb,KAAM,OACN,aAAc,eACd,OAAQ,SACR,KAAM,MACR,EAEA,IAAOC,EAAQD",
+  "names": ["LogicStepTypes", "logic_step_types_default"]
+}

package/dist/src/enums/loop_types.js

@@ -0,0 +1,2 @@
+const e={FOR:"for",FOR_EACH:"for_each",GENERATOR:"generator",WHILE:"while"};var o=e;export{o as default};
+//# sourceMappingURL=loop_types.js.map

package/dist/src/enums/loop_types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/enums/loop_types.js"],
+  "sourcesContent": ["/**\n * Enumeration of loop types for LoopStep.\n * \n * @enum {string}\n * @readonly\n */\nconst loop_types = {\n  FOR: 'for',\n  FOR_EACH: 'for_each',\n  GENERATOR: 'generator',\n  WHILE: 'while',\n};\n\nexport default loop_types;\n"],
+  "mappings": "AAMA,MAAMA,EAAa,CACjB,IAAK,MACL,SAAU,WACV,UAAW,YACX,MAAO,OACT,EAEA,IAAOC,EAAQD",
+  "names": ["loop_types", "loop_types_default"]
+}

package/dist/src/enums/state_event_names.js

@@ -0,0 +1,2 @@
+const e={DELETED:"deleted",EACH:"each",FROZEN:"frozen",GET:"get",GET_FROM_PROPERTY_PATH:"get_from_property_path",GET_STATE:"get_state",MERGE:"merge",RESET:"reset",SET:"set",SET_TO_PROPERTY_PATH:"set_to_property_path"};var t=e;export{t as default};
+//# sourceMappingURL=state_event_names.js.map

package/dist/src/enums/state_event_names.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/enums/state_event_names.js"],
+  "sourcesContent": ["/**\n * Enumeration of state event names.\n */\nconst state_event_names = {\n  DELETED: 'deleted',\n  EACH: 'each',\n  FROZEN: 'frozen',\n  GET: 'get',\n  GET_FROM_PROPERTY_PATH: 'get_from_property_path',\n  GET_STATE: 'get_state',\n  MERGE: 'merge',\n  RESET: 'reset',\n  SET: 'set',\n  SET_TO_PROPERTY_PATH: 'set_to_property_path',\n}\n\nexport default state_event_names;\n"],
+  "mappings": "AAGA,MAAMA,EAAoB,CACxB,QAAS,UACT,KAAM,OACN,OAAQ,SACR,IAAK,MACL,uBAAwB,yBACxB,UAAW,YACX,MAAO,QACP,MAAO,QACP,IAAK,MACL,qBAAsB,sBACxB,EAEA,IAAOC,EAAQD",
+  "names": ["state_event_names", "state_event_names_default"]
+}

package/dist/src/enums/step_event_names.js

@@ -0,0 +1,2 @@
+const _={CONDITIONAL_FALSE_BRANCH_EXECUTED:"conditional_false_branch_executed",CONDITIONAL_TRUE_BRANCH_EXECUTED:"conditional_true_branch_executed",DELAY_STEP_ABSOLUTE_SCHEDULED:"delay_step_absolute_scheduled",DELAY_STEP_RELATIVE_SCHEDULED:"delay_step_relative_scheduled",DELAY_STEP_ABSOLUTE_COMPLETE:"delay_step_absolute_complete",DELAY_STEP_RELATIVE_COMPLETE:"delay_step_relative_complete",LOOP_ITERATION_COMPLETE:"loop_iteration_complete",STEP_COMPLETE:"step_complete",STEP_FAILED:"step_failed",STEP_RUNNING:"step_running",STEP_PENDING:"step_pending",STEP_WAITING:"step_waiting",STEP_RETRYING:"step_retrying",SWITCH_CASE_MATCHED:"switch_case_matched"};var e=_;export{e as default};
+//# sourceMappingURL=step_event_names.js.map

package/dist/src/enums/step_event_names.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/enums/step_event_names.js"],
+  "sourcesContent": ["/**\n * Enumeration of step lifecycle event names.\n * Steps emit these events during their execution lifecycle.\n * \n * @enum {string}\n * @readonly\n */\nconst step_event_names = {\n  CONDITIONAL_FALSE_BRANCH_EXECUTED: 'conditional_false_branch_executed',\n  CONDITIONAL_TRUE_BRANCH_EXECUTED: 'conditional_true_branch_executed',\n  DELAY_STEP_ABSOLUTE_SCHEDULED: 'delay_step_absolute_scheduled',\n  DELAY_STEP_RELATIVE_SCHEDULED: 'delay_step_relative_scheduled',\n  DELAY_STEP_ABSOLUTE_COMPLETE: 'delay_step_absolute_complete',\n  DELAY_STEP_RELATIVE_COMPLETE: 'delay_step_relative_complete',\n  LOOP_ITERATION_COMPLETE: 'loop_iteration_complete',\n  STEP_COMPLETE: 'step_complete',\n  STEP_FAILED: 'step_failed',\n  STEP_RUNNING: 'step_running',\n  STEP_PENDING: 'step_pending',\n  STEP_WAITING: 'step_waiting',\n  STEP_RETRYING: 'step_retrying',\n  SWITCH_CASE_MATCHED: 'switch_case_matched',\n}\n\nexport default step_event_names;\n"],
+  "mappings": "AAOA,MAAMA,EAAmB,CACvB,kCAAmC,oCACnC,iCAAkC,mCAClC,8BAA+B,gCAC/B,8BAA+B,gCAC/B,6BAA8B,+BAC9B,6BAA8B,+BAC9B,wBAAyB,0BACzB,cAAe,gBACf,YAAa,cACb,aAAc,eACd,aAAc,eACd,aAAc,eACd,cAAe,gBACf,oBAAqB,qBACvB,EAEA,IAAOC,EAAQD",
+  "names": ["step_event_names", "step_event_names_default"]
+}

package/dist/src/enums/step_statuses.js

@@ -0,0 +1,2 @@
+const e={COMPLETE:"complete",FAILED:"failed",PENDING:"pending",QUEUED:"queued",RUNNING:"running",WAITING:"waiting"};var t=e;export{t as default};
+//# sourceMappingURL=step_statuses.js.map

package/dist/src/enums/step_statuses.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/enums/step_statuses.js"],
+  "sourcesContent": ["/**\n * Enumeration of possible step execution statuses.\n * Steps transition through these statuses during their lifecycle.\n * \n * @enum {string}\n * @readonly\n */\nconst step_statuses = {\n  COMPLETE: 'complete',\n  FAILED: 'failed',\n  PENDING: 'pending',\n  QUEUED: 'queued',\n  RUNNING: 'running',\n  WAITING: 'waiting',\n};\n\nexport default step_statuses;\n"],
+  "mappings": "AAOA,MAAMA,EAAgB,CACpB,SAAU,WACV,OAAQ,SACR,QAAS,UACT,OAAQ,SACR,QAAS,UACT,QAAS,SACX,EAEA,IAAOC,EAAQD",
+  "names": ["step_statuses", "step_statuses_default"]
+}

package/dist/src/enums/step_types.js

@@ -0,0 +1,2 @@
+const o={ACTION:"action",DELAY:"delay",LOGIC:"logic",LOOP:"loop"};var t=o;export{t as default};
+//# sourceMappingURL=step_types.js.map

package/dist/src/enums/step_types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/enums/step_types.js"],
+  "sourcesContent": ["/**\n * Enumeration of step types used throughout the workflow system.\n * These types categorize steps by their primary function.\n * \n * @enum {string}\n * @readonly\n */\nconst step_types = {\n  ACTION: 'action',\n  DELAY: 'delay',\n  LOGIC: 'logic',\n  LOOP: 'loop',\n};\n\nexport default step_types;\n"],
+  "mappings": "AAOA,MAAMA,EAAa,CACjB,OAAQ,SACR,MAAO,QACP,MAAO,QACP,KAAM,MACR,EAEA,IAAOC,EAAQD",
+  "names": ["step_types", "step_types_default"]
+}

package/dist/src/enums/sub_step_types.js

@@ -0,0 +1,2 @@
+const t={Step:"step",LogicStep:"logic",ConditionalStep:"conditional",FlowControlStep:"flow_control",LoopStep:"loop",SwitchStep:"switch",Case:"case",DelayStep:"delay"};var o=t;export{o as default};
+//# sourceMappingURL=sub_step_types.js.map

package/dist/src/enums/sub_step_types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/enums/sub_step_types.js"],
+  "sourcesContent": ["/**\n * Enumeration of sub-step types used in the workflow system.\n * @type {Object.<string, string>}\n * @readonly\n * @example\n * console.log(sub_step_types.Step); // \"step\"\n * console.log(sub_step_types.ConditionalStep); // \"conditional\"\n */\nconst sub_step_types = {\n  Step: 'step',\n  LogicStep: 'logic',\n  ConditionalStep: 'conditional',\n  FlowControlStep: 'flow_control',\n  LoopStep: 'loop',\n  SwitchStep: 'switch',\n  Case: 'case',\n  DelayStep: 'delay',\n};\n\nexport default sub_step_types;\n"],
+  "mappings": "AAQA,MAAMA,EAAiB,CACrB,KAAM,OACN,UAAW,QACX,gBAAiB,cACjB,gBAAiB,eACjB,SAAU,OACV,WAAY,SACZ,KAAM,OACN,UAAW,OACb,EAEA,IAAOC,EAAQD",
+  "names": ["sub_step_types", "sub_step_types_default"]
+}

package/dist/src/enums/workflow_event_names.js

@@ -0,0 +1,2 @@
+const _={WORKFLOW_BREAK_EXECUTED:"workflow_break_executed",WORKFLOW_CANCELLED:"workflow_cancelled",WORKFLOW_COMPLETE:"workflow_complete",WORKFLOW_CREATED:"workflow_created",WORKFLOW_ERRORED:"workflow_errored",WORKFLOW_FAILED:"workflow_failed",WORKFLOW_PAUSED:"workflow_paused",WORKFLOW_RESUMED:"workflow_resumed",WORKFLOW_RUNNING:"workflow_running",WORKFLOW_STEP_ADDED:"workflow_step_added",WORKFLOW_STEP_MOVED:"workflow_step_moved",WORKFLOW_STEP_REMOVED:"workflow_step_removed",WORKFLOW_STEP_SHIFTED:"workflow_step_shifted",WORKFLOW_STEP_SKIPPED:"workflow_step_skipped",WORKFLOW_STEPS_ADDED:"workflow_steps_added",WORKFLOW_STEPS_CLEARED:"workflow_steps_cleared"};var o=_;export{o as default};
+//# sourceMappingURL=workflow_event_names.js.map

package/dist/src/enums/workflow_event_names.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/enums/workflow_event_names.js"],
+  "sourcesContent": ["/**\n * Enumeration of workflow lifecycle event names.\n * Workflows emit these events during their creation and execution lifecycle.\n * \n * @enum {string}\n * @readonly\n */\nconst workflow_event_names = {\n  WORKFLOW_BREAK_EXECUTED: 'workflow_break_executed',\n  WORKFLOW_CANCELLED: 'workflow_cancelled',\n  WORKFLOW_COMPLETE: 'workflow_complete',\n  WORKFLOW_CREATED: 'workflow_created',\n  WORKFLOW_ERRORED: 'workflow_errored',\n  WORKFLOW_FAILED: 'workflow_failed',\n  WORKFLOW_PAUSED: 'workflow_paused',\n  WORKFLOW_RESUMED: 'workflow_resumed',\n  WORKFLOW_RUNNING: 'workflow_running',\n  WORKFLOW_STEP_ADDED: 'workflow_step_added',\n  WORKFLOW_STEP_MOVED: 'workflow_step_moved',\n  WORKFLOW_STEP_REMOVED: 'workflow_step_removed',\n  WORKFLOW_STEP_SHIFTED: 'workflow_step_shifted',\n  WORKFLOW_STEP_SKIPPED: 'workflow_step_skipped',\n  WORKFLOW_STEPS_ADDED: 'workflow_steps_added',\n  WORKFLOW_STEPS_CLEARED: 'workflow_steps_cleared',\n}\n\nexport default workflow_event_names;\n"],
+  "mappings": "AAOA,MAAMA,EAAuB,CAC3B,wBAAyB,0BACzB,mBAAoB,qBACpB,kBAAmB,oBACnB,iBAAkB,mBAClB,iBAAkB,mBAClB,gBAAiB,kBACjB,gBAAiB,kBACjB,iBAAkB,mBAClB,iBAAkB,mBAClB,oBAAqB,sBACrB,oBAAqB,sBACrB,sBAAuB,wBACvB,sBAAuB,wBACvB,sBAAuB,wBACvB,qBAAsB,uBACtB,uBAAwB,wBAC1B,EAEA,IAAOC,EAAQD",
+  "names": ["workflow_event_names", "workflow_event_names_default"]
+}

package/dist/src/enums/workflow_statuses.js

@@ -0,0 +1,2 @@
+const e={CANCELLED:"cancelled",COMPLETE:"complete",CREATED:"created",ERRORED:"errored",FROZEN:"frozen",FAILED:"failed",PAUSED:"paused",PENDING:"pending",RUNNING:"running",SKIPPED:"skipped"};var E=e;export{E as default};
+//# sourceMappingURL=workflow_statuses.js.map

package/dist/src/enums/workflow_statuses.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/enums/workflow_statuses.js"],
+  "sourcesContent": ["/**\n * Enumeration of possible workflow execution statuses.\n * Workflows transition through these statuses during their lifecycle.\n * \n * @enum {string}\n * @readonly\n */\nconst workflow_statuses = {\n  CANCELLED: 'cancelled',\n  COMPLETE: 'complete',\n  CREATED: 'created',\n  ERRORED: 'errored',\n  FROZEN: 'frozen',\n  FAILED: 'failed',\n  PAUSED: 'paused',\n  PENDING: 'pending',\n  RUNNING: 'running',\n  SKIPPED: 'skipped'\n};\n\nexport default workflow_statuses;\n"],
+  "mappings": "AAOA,MAAMA,EAAoB,CACxB,UAAW,YACX,SAAU,WACV,QAAS,UACT,QAAS,UACT,OAAQ,SACR,OAAQ,SACR,OAAQ,SACR,QAAS,UACT,QAAS,UACT,QAAS,SACX,EAEA,IAAOC,EAAQD",
+  "names": ["workflow_statuses", "workflow_statuses_default"]
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@ronaldroe/micro-flow",
+  "version": "0.0.9",
+  "description": "A lightweight, flexible workflow orchestration library for Node.js and browser environments. Build complex, sequential processes with ease using an intuitive API that supports conditional logic, flow control, event handling, and state management.",
+  "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "node build.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "workflow",
+    "orchestration",
+    "state-machine",
+    "flow-control",
+    "event-driven",
+    "browser",
+    "nodejs",
+    "state-management",
+    "sequential",
+    "process-automation"
+  ],
+  "author": "Starkey Software",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/starkeysoft/micro-flow.git"
+  },
+  "bugs": {
+    "url": "https://github.com/starkeysoft/micro-flow/issues"
+  },
+  "homepage": "https://github.com/starkeysoft/micro-flow#readme",
+  "files": [
+    "dist/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "date-fns": "^4.1.0",
+    "node-schedule": "^2.1.1",
+    "uuid": "^13.0.0"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^4.0.14",
+    "esbuild": "^0.27.0",
+    "vitest": "^4.0.14"
+  }
+}

package/src/classes/base.js

@@ -0,0 +1,143 @@
+import { v4 as uuidv4 } from 'uuid';
+import { base_types } from '../enums/index.js';
+import State from './state.js';
+
+/**
+ * Base class for workflows and steps.
+ * Provides common functionality for timing, status management, logging, and state access.
+ * @class Base
+ */
+export default class Base {
+  /**
+   * Creates a new Base instance.
+   * @param {Object} options - Configuration options.
+   * @param {string} [options.name] - Name of the instance.
+   * @param {string} [options.base_type=base_types.STEP] - Type of the base instance.
+   */
+  constructor({ name, base_type = base_types.STEP }) {
+    this.id = uuidv4();
+    this.name = name ?? `${base_type}-${this.id}`;
+
+    this.base_type = base_type;
+    this.timing = {
+      cancel_time: null,
+      complete_time: null,
+      end_time: null,
+      execution_time_ms: null,
+      start_time: null,
+    }
+  }
+
+  /**
+   * Executes the instance. Must be overridden by subclasses.
+   * @async
+   * @throws {Error} Throws if not implemented in subclass.
+   */
+  async execute() {
+    throw new Error('Execute method not implemented');
+  }
+
+  /**
+   * Logs an event and emits it to the appropriate event emitter.
+   * @param {string} event_name - Name of the event to log.
+   * @param {string} [message=null] - Optional message to log.
+   * @throws {Error} Throws if event name is invalid or event emitter not found.
+   */
+  log(event_name, message = null) {
+    if (!event_name || !State.get(`events.${this.base_type}`)) {
+      throw new Error('Invalid event name or event emitter not found');
+    }
+
+    State.get(`events.${this.base_type}`).emit(event_name, this);
+    if (State.get('log_suppress')) {
+      return;
+    }
+
+    const logMessage = message ? `\n[${this.base_type.toUpperCase()} - ${this.name}] ${message}` : `\n[${this.base_type.toUpperCase()} - ${this.name}] Event: ${event_name}`;
+    const logType = event_name.endsWith('_failed') ? 'error' : 'log';
+
+    console[logType](logMessage);
+  }
+
+  /**
+   * Marks the instance as complete and calculates execution time.
+   */
+  markAsComplete() {
+    this.timing.complete_time = new Date();
+    this.status = State.get('statuses')[this.base_type].COMPLETE;
+    this.timing.execution_time_ms = this.timing.complete_time - this.timing.start_time;
+
+    if (this.steps_by_id) {
+      delete this.steps_by_id;
+    }
+
+    this.log(
+      State.get(`event_names.${this.base_type}`)[`${this.base_type.toUpperCase()}_COMPLETE`],
+      `${this.base_type.charAt(0).toUpperCase() + this.base_type.slice(1)} "${this.name}" complete.`
+    );
+  }
+
+  /**
+   * Marks the instance as failed and calculates execution time.
+   */
+  markAsFailed() {
+    this.timing.complete_time = new Date();
+    this.status = State.get('statuses')[this.base_type].FAILED;
+    this.timing.execution_time_ms = this.timing.complete_time - this.timing.start_time;
+
+    this.log(
+      State.get(`event_names.${this.base_type}`)[`${this.base_type.toUpperCase()}_FAILED`],
+      `${this.base_type.charAt(0).toUpperCase() + this.base_type.slice(1)} "${this.name}" failed.`
+    );
+  }
+
+  /**
+   * Marks the instance as waiting. To be implemented by subclasses.
+   */
+  markAsWaiting() { }
+
+  /**
+   * Marks the instance as pending. To be implemented by subclasses.
+   */
+  markAsPending() { }
+
+  /**
+   * Marks the instance as running and sets the start time.
+   */
+  markAsRunning() {
+    this.timing.start_time = new Date();
+    this.status = State.get('statuses')[this.base_type].RUNNING;
+
+    this.log(
+      State.get(`event_names.${this.base_type}`)[`${this.base_type.toUpperCase()}_RUNNING`],
+      `${this.base_type.charAt(0).toUpperCase() + this.base_type.slice(1)} "${this.name}" started.`
+    );
+  }
+
+  // State management methods
+  /**
+   * Gets a value from the global state.
+   * @param {string} path - Path to the state property.
+   * @returns {*} The state value at the specified path.
+   */
+  getState(path) {
+    return State.get(path);
+  }
+
+  /**
+   * Sets a value in the global state.
+   * @param {string} path - Path to the state property.
+   * @param {*} value - Value to set.
+   */
+  setState(path, value) {
+    State.set(path, value);
+  }
+
+  /**
+   * Deletes a property from the global state.
+   * @param {string} path - Path to the state property to delete.
+   */
+  deleteState(path) {
+    State.delete(path);
+  }
+}

package/src/classes/events/broadcast.js

@@ -0,0 +1,57 @@
+/**
+ * Broadcast class provides a simplified wrapper around the BroadcastChannel API
+ * for cross-context communication (e.g., between tabs, windows, workers).
+ * 
+ * This class allows you to send and receive messages across different browsing contexts
+ * that share the same origin. It encapsulates the creation and management of a BroadcastChannel,
+ * providing a simplified API for sending and receiving messages.
+ * 
+ * @class Broadcast
+ * @extends BroadcastChannel
+ */
+export default class Broadcast extends BroadcastChannel {
+  /**
+   * Creates a new Broadcast instance for a named channel.
+   * 
+   * @constructor
+   * @param {string} channelName - The name of the broadcast channel to create or connect to.
+   * Multiple Broadcast instances with the same channel name can communicate with each other.
+   */
+  constructor(channelName) {
+    super(channelName);
+  }
+
+  /**
+   * Sends data to all other contexts listening on this channel.
+   * 
+   * @param {*} data - The data to broadcast. Can be any structured-cloneable value
+   * (primitives, objects, arrays, etc.). Functions and DOM nodes cannot be sent.
+   * @returns {void}
+   */
+  send(data) {
+    this.postMessage(data);
+  }
+
+  /**
+   * Registers a callback to handle incoming messages on this channel.
+   * 
+   * @param {Function} callback - Function to call when a message is received.
+   * Receives the message data as its only parameter.
+   * @returns {void}
+   */
+  onReceive(callback) {
+    this.onmessage = (event) => {
+      callback(event.data);
+    };
+  }
+
+  /**
+   * Closes the broadcast channel and releases its resources.
+   * After calling this method, the Broadcast instance can no longer send or receive messages.
+   * 
+   * @returns {void}
+   */
+  destroy() {
+    this.close();
+  }
+}

package/src/classes/events/event.js

@@ -0,0 +1,144 @@
+import { errors, warnings } from '../../enums/index.js';
+import Broadcast from './broadcast.js';
+
+/**
+ * Event class for micro-flow
+ * Provides a simple event emitter implementation for workflow steps and state changes.
+ *
+ * This class is used for emitting and listening to events within workflows and steps.
+ * For broadcasting events across multiple workflows or listeners, see the Broadcast class.
+ */
+class Event extends EventTarget {
+  /**
+   * Creates a new Event instance.
+   * @constructor
+   */
+  constructor() {
+    super();
+    this.events = {};
+    this._listener_map = new Map();
+  }
+
+  /**
+   * Registers multiple events by creating Event instances for each event name.
+   * @param {Object} event_names - An object containing event name constants.
+   * @returns {void}
+   */
+  registerEvents(event_names) {
+    for (const event_name of Object.values(event_names)) {
+      this.events[event_name] = new Event();
+    }
+  }
+
+  /**
+   * Emits a custom event with optional data payload.
+   * This method maintains API compatibility with EventEmitter while using CustomEvent.
+   * @param {string} event_name - The name of the event to emit.
+   * @param {*} [data] - Optional data to pass with the event in the detail property.
+   * @param {boolean} [bubbles=false] - Whether the event should bubble up through the DOM.
+   * @param {boolean} [cancelable=true] - Whether the event is cancelable.
+   * @returns {boolean} True if the event was not cancelled, false if it was cancelled.
+   */
+  emit(event_name, data, bubbles = false, cancelable = true) {
+    const workingData = JSON.parse(JSON.stringify(data));
+
+    const custom_event = new CustomEvent(event_name, {
+      detail: workingData,
+      bubbles,
+      cancelable
+    });
+    const result = this.dispatchEvent(custom_event);
+
+    try {
+      const channel = new Broadcast(event_name);
+      channel.send(workingData);
+      channel.destroy();
+    } catch (e) {
+      console.warn(warnings.BROADCAST_FAILED, e);
+    }
+    return result;
+  }
+
+  /**
+   * Listen for broadcasts on a given event name (channel).
+   * @param {string} event_name - The event name/channel to listen for.
+   * @param {Function} listener - Callback for broadcasted data.
+   * @returns {Broadcast} Returns the Broadcast instance for manual control.
+   */
+  onBroadcast(event_name, listener) {
+    const channel = new Broadcast(event_name);
+    channel.onReceive(listener);
+    return channel;
+  }
+
+  /**
+   * Listen for both local and broadcast events.
+   * @param {string} event_name - The event name/channel to listen for.
+   * @param {Function} listener - Callback for event data.
+   * @returns {Object} Returns { event: this, broadcast: Broadcast instance }
+   */
+  onAny(event_name, listener) {
+    this.on(event_name, listener);
+    const broadcast = this.onBroadcast(event_name, listener);
+    return { event: this, broadcast };
+  }
+
+  /**
+   * Adds an event listener with EventEmitter-style API.
+   * Maintains compatibility with the original API while using addEventListener.
+   * @param {string} event_name - The name of the event to listen for.
+   * @param {Function} listener - The callback function to execute when the event fires.
+   * @returns {Event} Returns this for chaining.
+   */
+  on(event_name, listener) {
+    const wrapped_listener = (event) => {
+      // Call the listener with the detail (data) from CustomEvent
+      listener(event.detail);
+    };
+    // Store the original listener reference for removeListener
+    this._listener_map.set(listener, wrapped_listener);
+    this.addEventListener(event_name, wrapped_listener);
+    return this;
+  }
+
+  /**
+   * Adds a one-time event listener with EventEmitter-style API.
+   * @param {string} event_name - The name of the event to listen for.
+   * @param {Function} listener - The callback function to execute when the event fires.
+   * @returns {Event} Returns this for chaining.
+   */
+  once(event_name, listener) {
+    const wrapped_listener = (event) => {
+      listener(event.detail);
+    };
+    this.addEventListener(event_name, wrapped_listener, { once: true });
+    return this;
+  }
+
+  /**
+   * Removes an event listener with EventEmitter-style API.
+   * @param {string} event_name - The name of the event.
+   * @param {Function} listener - The callback function to remove.
+   * @returns {Event} Returns this for chaining.
+   */
+  off(event_name, listener) {
+    if (this._listener_map && this._listener_map.has(listener)) {
+      const wrapped_listener = this._listener_map.get(listener);
+      this.removeEventListener(event_name, wrapped_listener);
+      this._listener_map.delete(listener);
+    }
+    return this;
+  }
+
+  /**
+   * Alias for off() to maintain EventEmitter API compatibility.
+   * @param {string} event_name - The name of the event.
+   * @param {Function} listener - The callback function to remove.
+   * @returns {Event} Returns this for chaining.
+   */
+  removeListener(event_name, listener) {
+    return this.off(event_name, listener);
+  }
+}
+
+export default Event;

package/src/classes/events/index.js

@@ -0,0 +1,5 @@
+export { default as Broadcast } from './broadcast.js';
+export { default as Event } from './event.js';
+export { default as StateEvent } from './state_event.js';
+export { default as StepEvent } from './step_event.js';
+export { default as WorkflowEvent } from './workflow_event.js';

package/src/classes/events/state_event.js

@@ -0,0 +1,28 @@
+import { Event } from './index.js';
+import { state_event_names } from '../../enums/index.js';
+
+/**
+ * Manages state-specific events by extending the base Event class.
+ * @class StateEvent
+ * @extends Event
+ */
+export default class StateEvent extends Event {
+  event_names = state_event_names;
+
+  /**
+   * Creates a new StateEvent instance and registers all state events.
+   * @constructor
+   */
+  constructor() {
+    super();
+    this.registerStateEvents();
+  }
+
+  /**
+   * Registers all state event names defined in the state_event_names enum.
+   * @returns {void}
+   */
+  registerStateEvents() {
+    this.registerEvents(this.event_names);
+  }
+}

package/src/classes/events/step_event.js

@@ -0,0 +1,28 @@
+import { Event } from './index.js';
+import { step_event_names } from '../../enums/index.js';
+
+/**
+ * Manages step-specific events by extending the base Event class.
+ * @class StepEvent
+ * @extends Event
+ */
+export default class StepEvent extends Event {
+  event_names = step_event_names;
+
+  /**
+   * Creates a new StepEvent instance and registers all step events.
+   * @constructor
+   */
+  constructor() {
+    super();
+    this.registerStepEvents();
+  }
+  
+  /**
+   * Registers all step event names defined in the step_event_names enum.
+   * @returns {void}
+   */
+  registerStepEvents() {
+    this.registerEvents(this.event_names);
+  }
+}