@mastra/core 0.1.27-alpha.26 → 0.1.27-alpha.27

package/dist/core.cjs.development.js

@@ -3671,7 +3671,7 @@ function isTransitionEvent(stateEvent) {
   return stateEvent.type.startsWith('xstate.done.actor.');
 }
 function isVariableReference(value) {
-  return typeof value === 'object' && 'stepId' in value && 'path' in value;
+  return typeof value === 'object' && 'step' in value && 'path' in value;
 }
 function getStepResult(result) {
   if ((result == null ? void 0 : result.status) === 'success') return result.payload;
@@ -3680,8 +3680,6 @@ function getStepResult(result) {
 
 var _logger = /*#__PURE__*/_classPrivateFieldLooseKey("logger");
 var _triggerSchema = /*#__PURE__*/_classPrivateFieldLooseKey("triggerSchema");
-var _steps = /*#__PURE__*/_classPrivateFieldLooseKey("steps");
-var _stepConfiguration = /*#__PURE__*/_classPrivateFieldLooseKey("stepConfiguration");
 var _machine = /*#__PURE__*/_classPrivateFieldLooseKey("machine");
 var _actor = /*#__PURE__*/_classPrivateFieldLooseKey("actor");
 var _runId = /*#__PURE__*/_classPrivateFieldLooseKey("runId");
@@ -3690,6 +3688,12 @@ var _engine = /*#__PURE__*/_classPrivateFieldLooseKey("engine");
 var _connectionId = /*#__PURE__*/_classPrivateFieldLooseKey("connectionId");
 var _entityName = /*#__PURE__*/_classPrivateFieldLooseKey("entityName");
 var _telemetry = /*#__PURE__*/_classPrivateFieldLooseKey("telemetry");
+var _lastStepStack = /*#__PURE__*/_classPrivateFieldLooseKey("lastStepStack");
+var _stepGraph = /*#__PURE__*/_classPrivateFieldLooseKey("stepGraph");
+var _steps = /*#__PURE__*/_classPrivateFieldLooseKey("steps");
+var _recursivelyCheckForFinalState = /*#__PURE__*/_classPrivateFieldLooseKey("recursivelyCheckForFinalState");
+var _buildBaseState = /*#__PURE__*/_classPrivateFieldLooseKey("buildBaseState");
+var _makeStepKey = /*#__PURE__*/_classPrivateFieldLooseKey("makeStepKey");
 var _buildStateHierarchy = /*#__PURE__*/_classPrivateFieldLooseKey("buildStateHierarchy");
 var _persistWorkflowSnapshot = /*#__PURE__*/_classPrivateFieldLooseKey("persistWorkflowSnapshot");
 var _loadWorkflowSnapshot = /*#__PURE__*/_classPrivateFieldLooseKey("loadWorkflowSnapshot");
@@ -3706,9 +3710,7 @@ var Workflow = /*#__PURE__*/function () {
    * @param logger - Optional logger instance
    */
   function Workflow(_ref) {
-    var _this = this;
     var name = _ref.name,
-      steps = _ref.steps,
       logger = _ref.logger,
       engine = _ref.engine,
       triggerSchema = _ref.triggerSchema,
@@ -3771,6 +3773,15 @@ var Workflow = /*#__PURE__*/function () {
     Object.defineProperty(this, _buildStateHierarchy, {
       value: _buildStateHierarchy2
     });
+    Object.defineProperty(this, _makeStepKey, {
+      value: _makeStepKey2
+    });
+    Object.defineProperty(this, _buildBaseState, {
+      value: _buildBaseState2
+    });
+    Object.defineProperty(this, _recursivelyCheckForFinalState, {
+      value: _recursivelyCheckForFinalState2
+    });
     this.name = void 0;
     Object.defineProperty(this, _logger, {
       writable: true,
@@ -3780,14 +3791,6 @@ var Workflow = /*#__PURE__*/function () {
       writable: true,
       value: void 0
     });
-    Object.defineProperty(this, _steps, {
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, _stepConfiguration, {
-      writable: true,
-      value: {}
-    });
     /** XState machine instance that orchestrates the workflow execution */
     Object.defineProperty(this, _machine, {
       writable: true,
@@ -3822,9 +3825,25 @@ var Workflow = /*#__PURE__*/function () {
       writable: true,
       value: void 0
     });
+    // registers stepIds on `after` calls
+    // #afterStepStack: string[] = [];
+    Object.defineProperty(this, _lastStepStack, {
+      writable: true,
+      value: []
+    });
+    Object.defineProperty(this, _stepGraph, {
+      writable: true,
+      value: {
+        initial: []
+      }
+    });
+    // #delimiter = '-([-]::[-])-';
+    Object.defineProperty(this, _steps, {
+      writable: true,
+      value: {}
+    });
     this.name = name;
     _classPrivateFieldLooseBase(this, _logger)[_logger] = logger;
-    _classPrivateFieldLooseBase(this, _steps)[_steps] = steps;
     _classPrivateFieldLooseBase(this, _retryConfig)[_retryConfig] = retryConfig || {
       attempts: 3,
       delay: 1000
@@ -3834,10 +3853,6 @@ var Workflow = /*#__PURE__*/function () {
     _classPrivateFieldLooseBase(this, _telemetry)[_telemetry] = telemetry;
     _classPrivateFieldLooseBase(this, _engine)[_engine] = engine;
     this.initializeMachine();
-    // Initialize step definitions
-    steps.forEach(function (step) {
-      _classPrivateFieldLooseBase(_this, _stepConfiguration)[_stepConfiguration][step.id] = _extends({}, _classPrivateFieldLooseBase(_this, _makeStepDef)[_makeStepDef](step.id));
-    });
   }
   /**
    * Initializes the XState machine for the workflow
@@ -3847,7 +3862,7 @@ var Workflow = /*#__PURE__*/function () {
    */
   var _proto = Workflow.prototype;
   _proto.initializeMachine = function initializeMachine() {
-    var _this2 = this;
+    var _this = this;
     var machine = xstate.setup({
       types: {},
       delays: _classPrivateFieldLooseBase(this, _makeDelayMap)[_makeDelayMap](),
@@ -3883,7 +3898,7 @@ var Workflow = /*#__PURE__*/function () {
         }),
         notifyStepCompletion: function notifyStepCompletion(_, params) {
           var stepId = params.stepId;
-          _classPrivateFieldLooseBase(_this2, _log)[_log](LogLevel.INFO, "Step " + stepId + " completed");
+          _classPrivateFieldLooseBase(_this, _log)[_log](LogLevel.INFO, "Step " + stepId + " completed");
         },
         decrementAttemptCount: xstate.assign({
           attempts: function attempts(_ref4, params) {
@@ -3901,25 +3916,27 @@ var Workflow = /*#__PURE__*/function () {
       actors: {
         resolverFunction: xstate.fromPromise(/*#__PURE__*/function () {
           var _ref6 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref5) {
-            var input, step, context, stepId, resolvedData, result;
+            var input, stepNode, context, resolvedData, result;
             return _regeneratorRuntime().wrap(function _callee$(_context) {
               while (1) switch (_context.prev = _context.next) {
                 case 0:
                   input = _ref5.input;
-                  step = input.step, context = input.context, stepId = input.stepId;
-                  resolvedData = _classPrivateFieldLooseBase(_this2, _resolveVariables)[_resolveVariables]({
-                    stepConfig: step,
+                  stepNode = input.stepNode, context = input.context;
+                  resolvedData = _classPrivateFieldLooseBase(_this, _resolveVariables)[_resolveVariables]({
+                    stepConfig: stepNode.config,
                     context: context
                   });
                   _context.next = 5;
-                  return step == null ? void 0 : step.handler({
-                    data: resolvedData,
-                    runId: _classPrivateFieldLooseBase(_this2, _runId)[_runId]
+                  return stepNode.config.handler({
+                    context: _extends({
+                      stepResults: context.stepResults
+                    }, resolvedData),
+                    runId: _classPrivateFieldLooseBase(_this, _runId)[_runId]
                   });
                 case 5:
                   result = _context.sent;
                   return _context.abrupt("return", {
-                    stepId: stepId,
+                    stepId: stepNode.step.id,
                     result: result
                   });
                 case 7:
@@ -3934,14 +3951,14 @@ var Workflow = /*#__PURE__*/function () {
         }()),
         dependencyCheck: xstate.fromPromise(/*#__PURE__*/function () {
           var _ref8 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(_ref7) {
-            var input, context, stepId, stepConfig, attemptCount, missingDeps, suspendedDeps, failedDeps, conditionMet, _conditionMet;
+            var input, context, stepNode, stepConfig, attemptCount, conditionMet, _conditionMet;
             return _regeneratorRuntime().wrap(function _callee2$(_context2) {
               while (1) switch (_context2.prev = _context2.next) {
                 case 0:
                   input = _ref7.input;
-                  context = input.context, stepId = input.stepId;
-                  stepConfig = _classPrivateFieldLooseBase(_this2, _stepConfiguration)[_stepConfiguration][stepId];
-                  attemptCount = context.attempts[stepId];
+                  context = input.context, stepNode = input.stepNode;
+                  stepConfig = stepNode.config; // TODO: Need a way to create unique ids for steps
+                  attemptCount = context.attempts[stepNode.step.id];
                   if (!(!attemptCount || attemptCount < 0)) {
                     _context2.next = 8;
                     break;
@@ -3952,90 +3969,58 @@ var Workflow = /*#__PURE__*/function () {
                   }
                   return _context2.abrupt("return", {
                     type: 'SUSPENDED',
-                    stepId: stepId
+                    stepId: stepNode.step.id
                   });
                 case 7:
                   return _context2.abrupt("return", {
                     type: 'TIMED_OUT',
-                    error: "Step:" + stepId + " timed out"
+                    error: "Step:" + stepNode.step.id + " timed out"
                   });
                 case 8:
-                  // Check dependencies are present and valid
-                  missingDeps = stepConfig == null ? void 0 : stepConfig.dependsOn.filter(function (depId) {
-                    return !(depId in context.stepResults);
-                  });
-                  suspendedDeps = stepConfig == null ? void 0 : stepConfig.dependsOn.filter(function (depId) {
-                    var _context$stepResults$;
-                    return ((_context$stepResults$ = context.stepResults[depId]) == null ? void 0 : _context$stepResults$.status) === 'suspended';
-                  });
-                  if (!(suspendedDeps != null && suspendedDeps.length && suspendedDeps.length > 0)) {
-                    _context2.next = 12;
+                  if (stepConfig != null && stepConfig.when) {
+                    _context2.next = 10;
                     break;
                   }
                   return _context2.abrupt("return", {
-                    type: 'SUSPENDED',
-                    stepId: stepId,
-                    missingDeps: suspendedDeps
-                  });
-                case 12:
-                  if (!(missingDeps != null && missingDeps.length && missingDeps.length > 0)) {
-                    _context2.next = 14;
-                    break;
-                  }
-                  return _context2.abrupt("return", {
-                    type: 'DEPENDENCIES_NOT_MET'
-                  });
-                case 14:
-                  failedDeps = stepConfig == null ? void 0 : stepConfig.dependsOn.filter(function (depId) {
-                    var _context$stepResults$2, _context$stepResults$3;
-                    return ((_context$stepResults$2 = context.stepResults[depId]) == null ? void 0 : _context$stepResults$2.status) === 'failed' || ((_context$stepResults$3 = context.stepResults[depId]) == null ? void 0 : _context$stepResults$3.status) === 'skipped';
+                    type: 'DEPENDENCIES_MET'
                   });
-                  if (!(failedDeps != null && failedDeps.length && failedDeps.length > 0)) {
-                    _context2.next = 17;
+                case 10:
+                  if (!(typeof (stepConfig == null ? void 0 : stepConfig.when) === 'function')) {
+                    _context2.next = 18;
                     break;
                   }
-                  return _context2.abrupt("return", {
-                    type: 'SKIP_STEP',
-                    missingDeps: failedDeps
+                  _context2.next = 13;
+                  return stepConfig.when({
+                    context: context
                   });
-                case 17:
-                  if (!(stepConfig != null && stepConfig.condition)) {
-                    _context2.next = 21;
-                    break;
-                  }
-                  conditionMet = _classPrivateFieldLooseBase(_this2, _evaluateCondition)[_evaluateCondition](stepConfig.condition, context);
+                case 13:
+                  conditionMet = _context2.sent;
                   if (conditionMet) {
-                    _context2.next = 21;
+                    _context2.next = 16;
                     break;
                   }
                   return _context2.abrupt("return", {
                     type: 'CONDITION_FAILED',
-                    error: "Step:" + stepId + " condition check failed"
-                  });
-                case 21:
-                  if (!(stepConfig != null && stepConfig.conditionFn)) {
-                    _context2.next = 27;
-                    break;
-                  }
-                  _context2.next = 24;
-                  return stepConfig.conditionFn({
-                    context: context
+                    error: "Step:" + stepNode.step.id + " condition function check failed"
                   });
-                case 24:
-                  _conditionMet = _context2.sent;
+                case 16:
+                  _context2.next = 21;
+                  break;
+                case 18:
+                  _conditionMet = _classPrivateFieldLooseBase(_this, _evaluateCondition)[_evaluateCondition](stepConfig.when, context);
                   if (_conditionMet) {
-                    _context2.next = 27;
+                    _context2.next = 21;
                     break;
                   }
                   return _context2.abrupt("return", {
                     type: 'CONDITION_FAILED',
-                    error: "Step:" + stepId + " condition function check failed"
+                    error: "Step:" + stepNode.step.id + " condition check failed"
                   });
-                case 27:
+                case 21:
                   return _context2.abrupt("return", {
                     type: 'DEPENDENCIES_MET'
                   });
-                case 28:
+                case 22:
                 case "end":
                   return _context2.stop();
               }
@@ -4057,19 +4042,11 @@ var Workflow = /*#__PURE__*/function () {
     });
     _classPrivateFieldLooseBase(this, _machine)[_machine] = machine;
     return machine;
-  }
-  /**
-   * Configures a step in the workflow
-   * @param id - Unique identifier for the step
-   * @param config - Step configuration including handler, schema, variables, and payload
-   * @returns this instance for method chaining
-   */;
-  _proto.config = function config(id, _config) {
-    var _config$variables = _config.variables,
-      variables = _config$variables === void 0 ? {} : _config$variables,
-      dependsOn = _config.dependsOn,
-      condition = _config.condition,
-      conditionFn = _config.conditionFn;
+  };
+  _proto.step = function step(_step, config) {
+    var _ref10 = config || {},
+      _ref10$variables = _ref10.variables,
+      variables = _ref10$variables === void 0 ? {} : _ref10$variables;
     var requiredData = {};
     // Add valid variables to requiredData
     for (var _i = 0, _Object$entries = Object.entries(variables); _i < _Object$entries.length; _i++) {
@@ -4080,12 +4057,48 @@ var Workflow = /*#__PURE__*/function () {
         requiredData[key] = variable;
       }
     }
-    _classPrivateFieldLooseBase(this, _stepConfiguration)[_stepConfiguration][id] = _extends({}, _classPrivateFieldLooseBase(this, _makeStepDef)[_makeStepDef](id), {
-      dependsOn: dependsOn,
-      condition: condition,
-      conditionFn: conditionFn,
-      data: requiredData
-    });
+    var stepKey = _classPrivateFieldLooseBase(this, _makeStepKey)[_makeStepKey](_step);
+    var graphEntry = {
+      step: _step,
+      config: _extends({}, _classPrivateFieldLooseBase(this, _makeStepDef)[_makeStepDef](stepKey), config, {
+        data: requiredData
+      })
+    };
+    _classPrivateFieldLooseBase(this, _steps)[_steps][stepKey] = _step;
+    if (!_classPrivateFieldLooseBase(this, _stepGraph)[_stepGraph][stepKey]) _classPrivateFieldLooseBase(this, _stepGraph)[_stepGraph][stepKey] = [];
+    _classPrivateFieldLooseBase(this, _stepGraph)[_stepGraph].initial.push(graphEntry);
+    _classPrivateFieldLooseBase(this, _lastStepStack)[_lastStepStack].push(stepKey);
+    return this;
+  };
+  _proto.then = function then(step, config) {
+    var _ref11 = config || {},
+      _ref11$variables = _ref11.variables,
+      variables = _ref11$variables === void 0 ? {} : _ref11$variables;
+    var requiredData = {};
+    // Add valid variables to requiredData
+    for (var _i2 = 0, _Object$entries2 = Object.entries(variables); _i2 < _Object$entries2.length; _i2++) {
+      var _Object$entries2$_i = _Object$entries2[_i2],
+        key = _Object$entries2$_i[0],
+        variable = _Object$entries2$_i[1];
+      if (variable && isVariableReference(variable)) {
+        requiredData[key] = variable;
+      }
+    }
+    var lastStepKey = _classPrivateFieldLooseBase(this, _lastStepStack)[_lastStepStack][_classPrivateFieldLooseBase(this, _lastStepStack)[_lastStepStack].length - 1];
+    var stepKey = _classPrivateFieldLooseBase(this, _makeStepKey)[_makeStepKey](step);
+    var graphEntry = {
+      step: step,
+      config: _extends({}, _classPrivateFieldLooseBase(this, _makeStepDef)[_makeStepDef](stepKey), config, {
+        data: requiredData
+      })
+    };
+    _classPrivateFieldLooseBase(this, _steps)[_steps][stepKey] = step;
+    // if then is called without a step, we are done
+    if (!lastStepKey) return this;
+    // add the step to the graph if not already there.. it should be there though, unless magic
+    if (!_classPrivateFieldLooseBase(this, _stepGraph)[_stepGraph][lastStepKey]) _classPrivateFieldLooseBase(this, _stepGraph)[_stepGraph][lastStepKey] = [];
+    // add the step to the graph
+    _classPrivateFieldLooseBase(this, _stepGraph)[_stepGraph][lastStepKey].push(graphEntry);
     return this;
   }
   /**
@@ -4098,12 +4111,12 @@ var Workflow = /*#__PURE__*/function () {
   /*#__PURE__*/
   function () {
     var _execute = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(_temp) {
-      var _this3 = this;
-      var _ref10, triggerData, loadSnapshot, snapshot;
+      var _this2 = this;
+      var _ref12, triggerData, loadSnapshot, snapshot;
       return _regeneratorRuntime().wrap(function _callee3$(_context3) {
         while (1) switch (_context3.prev = _context3.next) {
           case 0:
-            _ref10 = _temp === void 0 ? {} : _temp, triggerData = _ref10.triggerData, loadSnapshot = _ref10.loadSnapshot;
+            _ref12 = _temp === void 0 ? {} : _temp, triggerData = _ref12.triggerData, loadSnapshot = _ref12.loadSnapshot;
             if (!(loadSnapshot && loadSnapshot.runId)) {
               _context3.next = 7;
               break;
@@ -4150,9 +4163,9 @@ var Workflow = /*#__PURE__*/function () {
               input: {
                 stepResults: {},
                 triggerData: triggerData || {},
-                attempts: _classPrivateFieldLooseBase(this, _steps)[_steps].reduce(function (acc, step) {
-                  var _step$retryConfig, _classPrivateFieldLoo;
-                  acc[step.id] = ((_step$retryConfig = step.retryConfig) == null ? void 0 : _step$retryConfig.attempts) || ((_classPrivateFieldLoo = _classPrivateFieldLooseBase(_this3, _retryConfig)[_retryConfig]) == null ? void 0 : _classPrivateFieldLoo.attempts) || 3;
+                attempts: Object.keys(_classPrivateFieldLooseBase(this, _steps)[_steps]).reduce(function (acc, stepKey) {
+                  var _classPrivateFieldLoo, _classPrivateFieldLoo2;
+                  acc[stepKey] = ((_classPrivateFieldLoo = _classPrivateFieldLooseBase(_this2, _steps)[_steps][stepKey]) == null || (_classPrivateFieldLoo = _classPrivateFieldLoo.retryConfig) == null ? void 0 : _classPrivateFieldLoo.attempts) || ((_classPrivateFieldLoo2 = _classPrivateFieldLooseBase(_this2, _retryConfig)[_retryConfig]) == null ? void 0 : _classPrivateFieldLoo2.attempts) || 3;
                   return acc;
                 }, {})
               },
@@ -4160,16 +4173,14 @@ var Workflow = /*#__PURE__*/function () {
             });
             _classPrivateFieldLooseBase(this, _actor)[_actor].start();
             return _context3.abrupt("return", new Promise(function (resolve, reject) {
-              if (!_classPrivateFieldLooseBase(_this3, _actor)[_actor]) {
+              if (!_classPrivateFieldLooseBase(_this2, _actor)[_actor]) {
                 reject(new Error('Actor not initialized'));
                 return;
               }
-              _classPrivateFieldLooseBase(_this3, _actor)[_actor].subscribe(function (state) {
+              _classPrivateFieldLooseBase(_this2, _actor)[_actor].subscribe(function (state) {
                 // Check if all parallel states are in a final state
                 var allStatesValue = state.value;
-                var allStatesComplete = Object.values(allStatesValue).every(function (value) {
-                  return ['completed', 'failed', 'skipped', 'suspended'].includes(value);
-                });
+                var allStatesComplete = _classPrivateFieldLooseBase(_this2, _recursivelyCheckForFinalState)[_recursivelyCheckForFinalState](allStatesValue);
                 if (allStatesComplete) {
                   // Check if any steps failed
                   var hasFailures = Object.values(state.context.stepResults).some(function (result) {
@@ -4179,27 +4190,27 @@ var Workflow = /*#__PURE__*/function () {
                     return result.status === 'suspended';
                   });
                   if (hasSuspended) {
-                    _classPrivateFieldLooseBase(_this3, _persistWorkflowSnapshot)[_persistWorkflowSnapshot]();
+                    _classPrivateFieldLooseBase(_this2, _persistWorkflowSnapshot)[_persistWorkflowSnapshot]();
                   }
                   if (hasFailures) {
-                    _classPrivateFieldLooseBase(_this3, _log)[_log](LogLevel.ERROR, 'Workflow failed', {
+                    _classPrivateFieldLooseBase(_this2, _log)[_log](LogLevel.ERROR, 'Workflow failed', {
                       results: state.context.stepResults
                     });
-                    _classPrivateFieldLooseBase(_this3, _cleanup)[_cleanup]();
+                    _classPrivateFieldLooseBase(_this2, _cleanup)[_cleanup]();
                     resolve({
                       triggerData: triggerData,
                       results: state.context.stepResults,
-                      runId: _classPrivateFieldLooseBase(_this3, _runId)[_runId]
+                      runId: _classPrivateFieldLooseBase(_this2, _runId)[_runId]
                     });
                   } else {
-                    _classPrivateFieldLooseBase(_this3, _log)[_log](LogLevel.INFO, 'Workflow completed', {
+                    _classPrivateFieldLooseBase(_this2, _log)[_log](LogLevel.INFO, 'Workflow completed', {
                       results: state.context.stepResults
                     });
-                    _classPrivateFieldLooseBase(_this3, _cleanup)[_cleanup]();
+                    _classPrivateFieldLooseBase(_this2, _cleanup)[_cleanup]();
                     resolve({
                       triggerData: triggerData,
                       results: state.context.stepResults,
-                      runId: _classPrivateFieldLooseBase(_this3, _runId)[_runId]
+                      runId: _classPrivateFieldLooseBase(_this2, _runId)[_runId]
                     });
                   }
                 }
@@ -4239,204 +4250,219 @@ var Workflow = /*#__PURE__*/function () {
   _proto.__registerTelemetry = function __registerTelemetry(telemetry) {
     _classPrivateFieldLooseBase(this, _telemetry)[_telemetry] = telemetry;
   };
-  return Workflow;
+  return _createClass(Workflow, [{
+    key: "stepGraph",
+    get: function get() {
+      return _classPrivateFieldLooseBase(this, _stepGraph)[_stepGraph];
+    }
+  }]);
 }();
-function _buildStateHierarchy2() {
-  var _this4 = this;
-  var states = {};
-  _classPrivateFieldLooseBase(this, _steps)[_steps].forEach(function (step) {
-    var _after;
-    states[step.id] = {
-      initial: 'pending',
-      states: {
-        pending: {
-          invoke: {
-            src: 'dependencyCheck',
-            input: function input(_ref11) {
-              var context = _ref11.context;
-              return {
-                context: context,
-                stepId: step.id
-              };
+function _recursivelyCheckForFinalState2(value) {
+  var _this3 = this;
+  if (typeof value === 'string') {
+    return ['completed', 'failed', 'suspended'].includes(value);
+  }
+  return Object.values(value).every(function (val) {
+    return _classPrivateFieldLooseBase(_this3, _recursivelyCheckForFinalState)[_recursivelyCheckForFinalState](val);
+  });
+}
+function _buildBaseState2(stepNode, nextSteps) {
+  var _this4 = this,
+    _after,
+    _ref25;
+  if (nextSteps === void 0) {
+    nextSteps = [];
+  }
+  // NOTE: THIS CLEARS THE STEPGRAPH :: no concequences for now
+  var nextStep = nextSteps.shift();
+  return {
+    initial: 'pending',
+    entry: function entry(_ref13) {
+      var context = _ref13.context;
+      console.log({
+        stepNode: stepNode,
+        context: context
+      }, 'entry pending =============================');
+    },
+    exit: function exit(_ref14) {
+      var context = _ref14.context;
+      console.log({
+        stepNode: stepNode,
+        context: context
+      }, 'exit pending =============================');
+    },
+    states: _extends({
+      pending: {
+        invoke: {
+          src: 'dependencyCheck',
+          input: function input(_ref15) {
+            var context = _ref15.context;
+            return {
+              context: context,
+              stepNode: stepNode
+            };
+          },
+          onDone: [{
+            guard: function guard(_ref16) {
+              var event = _ref16.event;
+              return event.output.type === 'SUSPENDED';
             },
-            onDone: [{
-              guard: function guard(_ref12) {
-                var event = _ref12.event;
-                return event.output.type === 'SUSPENDED';
-              },
-              target: 'suspended',
-              actions: xstate.assign({
-                stepResults: function stepResults(_ref13) {
-                  var _extends5;
-                  var context = _ref13.context,
-                    event = _ref13.event;
-                  if (event.output.type !== 'SUSPENDED') return context.stepResults;
-                  return _extends({}, context.stepResults, (_extends5 = {}, _extends5[step.id] = {
-                    status: 'suspended'
-                  }, _extends5));
-                }
-              })
-            }, {
-              guard: function guard(_ref14) {
-                var event = _ref14.event;
-                return event.output.type === 'DEPENDENCIES_MET';
-              },
-              target: 'executing'
-            }, {
-              guard: function guard(_ref15) {
-                var event = _ref15.event;
-                return event.output.type === 'DEPENDENCIES_NOT_MET';
-              },
-              target: 'waiting',
-              actions: [{
-                type: 'decrementAttemptCount',
-                params: {
-                  stepId: step.id
-                }
-              }]
-            }, {
-              guard: function guard(_ref16) {
-                var event = _ref16.event;
-                return event.output.type === 'SKIP_STEP';
-              },
-              target: 'skipped',
-              actions: xstate.assign({
-                stepResults: function stepResults(_ref17) {
-                  var _extends6;
-                  var context = _ref17.context,
-                    event = _ref17.event;
-                  if (event.output.type !== 'SKIP_STEP') return context.stepResults;
-                  return _extends({}, context.stepResults, (_extends6 = {}, _extends6[step.id] = {
-                    status: 'skipped',
-                    missingDeps: event.output.missingDeps
-                  }, _extends6));
-                }
-              })
-            }, {
-              guard: function guard(_ref18) {
-                var event = _ref18.event;
-                return event.output.type === 'TIMED_OUT';
-              },
-              target: 'failed',
-              actions: xstate.assign({
-                stepResults: function stepResults(_ref19) {
-                  var _extends7;
-                  var context = _ref19.context,
-                    event = _ref19.event;
-                  if (event.output.type !== 'TIMED_OUT') return context.stepResults;
-                  _classPrivateFieldLooseBase(_this4, _log)[_log](LogLevel.ERROR, "Step:" + step.id + " timed out", {
-                    error: event.output.error
-                  });
-                  return _extends({}, context.stepResults, (_extends7 = {}, _extends7[step.id] = {
-                    status: 'failed',
-                    error: event.output.error
-                  }, _extends7));
-                }
-              })
-            }, {
-              guard: function guard(_ref20) {
-                var event = _ref20.event;
-                return event.output.type === 'CONDITION_FAILED';
-              },
-              target: 'failed',
-              actions: xstate.assign({
-                stepResults: function stepResults(_ref21) {
-                  var _extends8;
-                  var context = _ref21.context,
-                    event = _ref21.event;
-                  if (event.output.type !== 'CONDITION_FAILED') return context.stepResults;
-                  _classPrivateFieldLooseBase(_this4, _log)[_log](LogLevel.ERROR, "workflow condition check failed", {
-                    error: event.output.error,
-                    stepId: step.id
-                  });
-                  return _extends({}, context.stepResults, (_extends8 = {}, _extends8[step.id] = {
-                    status: 'failed',
-                    error: event.output.error
-                  }, _extends8));
-                }
-              })
+            target: 'suspended',
+            actions: xstate.assign({
+              stepResults: function stepResults(_ref17) {
+                var _extends5;
+                var context = _ref17.context,
+                  event = _ref17.event;
+                if (event.output.type !== 'SUSPENDED') return context.stepResults;
+                return _extends({}, context.stepResults, (_extends5 = {}, _extends5[stepNode.step.id] = {
+                  status: 'suspended'
+                }, _extends5));
+              }
+            })
+          }, {
+            guard: function guard(_ref18) {
+              var event = _ref18.event;
+              return event.output.type === 'DEPENDENCIES_MET';
+            },
+            target: 'executing'
+          }, {
+            guard: function guard(_ref19) {
+              var event = _ref19.event;
+              return event.output.type === 'DEPENDENCIES_NOT_MET';
+            },
+            target: 'waiting',
+            actions: [{
+              type: 'decrementAttemptCount',
+              params: {
+                stepId: stepNode.step.id
+              }
             }]
-          }
-        },
-        waiting: {
-          entry: function entry() {
-            _classPrivateFieldLooseBase(_this4, _log)[_log](LogLevel.INFO, "Step " + step.id + " waiting " + new Date().toISOString());
-          },
-          exit: function exit() {
-            _classPrivateFieldLooseBase(_this4, _log)[_log](LogLevel.INFO, "Step " + step.id + " finished waiting " + new Date().toISOString());
-          },
-          after: (_after = {}, _after[step.id] = {
-            target: 'pending'
-          }, _after)
-        },
-        executing: {
-          invoke: {
-            src: 'resolverFunction',
-            input: function input(_ref22) {
-              var context = _ref22.context;
-              return {
-                context: context,
-                stepId: step.id,
-                step: _classPrivateFieldLooseBase(_this4, _stepConfiguration)[_stepConfiguration][step.id]
-              };
+          }, {
+            guard: function guard(_ref20) {
+              var event = _ref20.event;
+              return event.output.type === 'TIMED_OUT';
             },
-            onDone: {
-              target: 'completed',
-              actions: [{
-                type: 'updateStepResult',
-                params: {
-                  stepId: step.id
-                }
-              }]
+            target: 'failed',
+            actions: xstate.assign({
+              stepResults: function stepResults(_ref21) {
+                var _extends6;
+                var context = _ref21.context,
+                  event = _ref21.event;
+                if (event.output.type !== 'TIMED_OUT') return context.stepResults;
+                _classPrivateFieldLooseBase(_this4, _log)[_log](LogLevel.ERROR, "Step:" + stepNode.step.id + " timed out", {
+                  error: event.output.error
+                });
+                return _extends({}, context.stepResults, (_extends6 = {}, _extends6[stepNode.step.id] = {
+                  status: 'failed',
+                  error: event.output.error
+                }, _extends6));
+              }
+            })
+          }, {
+            guard: function guard(_ref22) {
+              var event = _ref22.event;
+              return event.output.type === 'CONDITION_FAILED';
             },
-            onError: {
-              target: 'failed',
-              actions: [{
-                type: 'setStepError',
-                params: {
-                  stepId: step.id
-                }
-              }]
-            }
-          }
-        },
-        completed: {
-          type: 'final',
-          entry: [{
-            type: 'notifyStepCompletion',
-            params: {
-              stepId: step.id
-            }
+            target: 'failed',
+            actions: xstate.assign({
+              stepResults: function stepResults(_ref23) {
+                var _extends7;
+                var context = _ref23.context,
+                  event = _ref23.event;
+                if (event.output.type !== 'CONDITION_FAILED') return context.stepResults;
+                _classPrivateFieldLooseBase(_this4, _log)[_log](LogLevel.ERROR, "workflow condition check failed", {
+                  error: event.output.error,
+                  stepId: stepNode.step.id
+                });
+                return _extends({}, context.stepResults, (_extends7 = {}, _extends7[stepNode.step.id] = {
+                  status: 'failed',
+                  error: event.output.error
+                }, _extends7));
+              }
+            })
           }]
+        }
+      },
+      waiting: {
+        entry: function entry() {
+          _classPrivateFieldLooseBase(_this4, _log)[_log](LogLevel.INFO, "Step " + stepNode.step.id + " waiting " + new Date().toISOString());
         },
-        failed: {
-          type: 'final',
-          entry: [{
-            type: 'notifyStepCompletion',
-            params: {
-              stepId: step.id
-            }
-          }]
+        exit: function exit() {
+          _classPrivateFieldLooseBase(_this4, _log)[_log](LogLevel.INFO, "Step " + stepNode.step.id + " finished waiting " + new Date().toISOString());
         },
-        skipped: {
-          type: 'final',
-          entry: [{
-            type: 'notifyStepCompletion',
-            params: {
-              stepId: step.id
-            }
-          }]
-        },
-        suspended: {
-          entry: [{
-            type: 'notifyStepCompletion',
-            params: {
-              stepId: step.id
-            }
-          }]
+        after: (_after = {}, _after[stepNode.step.id] = {
+          target: 'pending'
+        }, _after)
+      },
+      executing: {
+        invoke: {
+          src: 'resolverFunction',
+          input: function input(_ref24) {
+            var context = _ref24.context;
+            return {
+              context: context,
+              stepNode: stepNode
+            };
+          },
+          onDone: {
+            target: nextStep ? nextStep.step.id : 'completed',
+            actions: [{
+              type: 'updateStepResult',
+              params: {
+                stepId: stepNode.step.id
+              }
+            }]
+          },
+          onError: {
+            target: 'failed',
+            actions: [{
+              type: 'setStepError',
+              params: {
+                stepId: stepNode.step.id
+              }
+            }]
+          }
         }
+      },
+      completed: {
+        type: 'final',
+        entry: [{
+          type: 'notifyStepCompletion',
+          params: {
+            stepId: stepNode.step.id
+          }
+        }]
+      },
+      failed: {
+        type: 'final',
+        entry: [{
+          type: 'notifyStepCompletion',
+          params: {
+            stepId: stepNode.step.id
+          }
+        }]
+      },
+      suspended: {
+        entry: [{
+          type: 'notifyStepCompletion',
+          params: {
+            stepId: stepNode.step.id
+          }
+        }]
       }
-    };
+    }, nextStep ? (_ref25 = {}, _ref25[nextStep.step.id] = _extends({}, _classPrivateFieldLooseBase(this, _buildBaseState)[_buildBaseState](nextStep, nextSteps)), _ref25) : {})
+  };
+}
+function _makeStepKey2(step) {
+  // return `${step.id}${this.#delimiter}${Object.keys(this.#steps2).length}`;
+  return "" + step.id;
+}
+function _buildStateHierarchy2() {
+  var _this5 = this;
+  var states = {};
+  _classPrivateFieldLooseBase(this, _stepGraph)[_stepGraph].initial.forEach(function (stepNode) {
+    // TODO: For identical steps, use index to create unique key
+    states[stepNode.step.id] = _extends({}, _classPrivateFieldLooseBase(_this5, _buildBaseState)[_buildBaseState](stepNode, _classPrivateFieldLooseBase(_this5, _stepGraph)[_stepGraph][stepNode.step.id]));
   });
   return states;
 }
@@ -4445,7 +4471,7 @@ function _persistWorkflowSnapshot2() {
 }
 function _persistWorkflowSnapshot3() {
   _persistWorkflowSnapshot3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
-    var _classPrivateFieldLoo3;
+    var _classPrivateFieldLoo5;
     var snapshot;
     return _regeneratorRuntime().wrap(function _callee5$(_context5) {
       while (1) switch (_context5.prev = _context5.next) {
@@ -4456,7 +4482,7 @@ function _persistWorkflowSnapshot3() {
           }
           return _context5.abrupt("return");
         case 2:
-          snapshot = (_classPrivateFieldLoo3 = _classPrivateFieldLooseBase(this, _actor)[_actor]) == null ? void 0 : _classPrivateFieldLoo3.getPersistedSnapshot();
+          snapshot = (_classPrivateFieldLoo5 = _classPrivateFieldLooseBase(this, _actor)[_actor]) == null ? void 0 : _classPrivateFieldLoo5.getPersistedSnapshot();
           if (snapshot) {
             _context5.next = 5;
             break;
@@ -4523,17 +4549,17 @@ function _loadWorkflowSnapshot3() {
   }));
   return _loadWorkflowSnapshot3.apply(this, arguments);
 }
-function _resolveVariables2(_ref23) {
-  var stepConfig = _ref23.stepConfig,
-    context = _ref23.context;
+function _resolveVariables2(_ref26) {
+  var stepConfig = _ref26.stepConfig,
+    context = _ref26.context;
   var resolvedData = {};
-  for (var _i2 = 0, _Object$entries2 = Object.entries(stepConfig.data); _i2 < _Object$entries2.length; _i2++) {
-    var _Object$entries2$_i = _Object$entries2[_i2],
-      key = _Object$entries2$_i[0],
-      variable = _Object$entries2$_i[1];
+  for (var _i3 = 0, _Object$entries3 = Object.entries(stepConfig.data); _i3 < _Object$entries3.length; _i3++) {
+    var _Object$entries3$_i = _Object$entries3[_i3],
+      key = _Object$entries3$_i[0],
+      variable = _Object$entries3$_i[1];
     // Check if variable comes from trigger data or a previous step's result
-    var sourceData = variable.stepId === 'trigger' ? context.triggerData : getStepResult(context.stepResults[variable.stepId]);
-    if (!sourceData && variable.stepId !== 'trigger') {
+    var sourceData = variable.step === 'trigger' ? context.triggerData : getStepResult(context.stepResults[variable.step.id]);
+    if (!sourceData && variable.step !== 'trigger') {
       resolvedData[key] = undefined;
       continue;
     }
@@ -4544,7 +4570,7 @@ function _resolveVariables2(_ref23) {
   return resolvedData;
 }
 function _evaluateCondition2(condition, context) {
-  var _this5 = this;
+  var _this6 = this;
   var andBranchResult = true;
   var baseResult = true;
   var orBranchResult = true;
@@ -4552,7 +4578,7 @@ function _evaluateCondition2(condition, context) {
   if ('ref' in condition) {
     var ref = condition.ref,
       query = condition.query;
-    var sourceData = ref.stepId === 'trigger' ? context.triggerData : getStepResult(context.stepResults[ref.stepId]);
+    var sourceData = ref.step === 'trigger' ? context.triggerData : getStepResult(context.stepResults[ref.step.id]);
     if (!sourceData) {
       return false;
     }
@@ -4562,13 +4588,13 @@ function _evaluateCondition2(condition, context) {
   // AND condition
   if ('and' in condition) {
     andBranchResult = condition.and.every(function (cond) {
-      return _classPrivateFieldLooseBase(_this5, _evaluateCondition)[_evaluateCondition](cond, context);
+      return _classPrivateFieldLooseBase(_this6, _evaluateCondition)[_evaluateCondition](cond, context);
     });
   }
   // OR condition
   if ('or' in condition) {
     orBranchResult = condition.or.some(function (cond) {
-      return _classPrivateFieldLooseBase(_this5, _evaluateCondition)[_evaluateCondition](cond, context);
+      return _classPrivateFieldLooseBase(_this6, _evaluateCondition)[_evaluateCondition](cond, context);
     });
   }
   var finalResult = baseResult && andBranchResult && orBranchResult;
@@ -4579,7 +4605,7 @@ function _log2(_x5, _x6, _x7, _x8) {
 }
 function _log3() {
   _log3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee7(level, message, data, stepId) {
-    var _classPrivateFieldLoo4, _classPrivateFieldLoo5;
+    var _classPrivateFieldLoo6, _classPrivateFieldLoo7;
     var logMessage, logMethod;
     return _regeneratorRuntime().wrap(function _callee7$(_context7) {
       while (1) switch (_context7.prev = _context7.next) {
@@ -4601,7 +4627,7 @@ function _log3() {
           };
           logMethod = level.toLowerCase();
           _context7.next = 6;
-          return (_classPrivateFieldLoo4 = (_classPrivateFieldLoo5 = _classPrivateFieldLooseBase(this, _logger)[_logger])[logMethod]) == null ? void 0 : _classPrivateFieldLoo4.call(_classPrivateFieldLoo5, logMessage);
+          return (_classPrivateFieldLoo6 = (_classPrivateFieldLoo7 = _classPrivateFieldLooseBase(this, _logger)[_logger])[logMethod]) == null ? void 0 : _classPrivateFieldLoo6.call(_classPrivateFieldLoo7, logMessage);
         case 6:
         case "end":
           return _context7.stop();
@@ -4611,55 +4637,52 @@ function _log3() {
   return _log3.apply(this, arguments);
 }
 function _makeStepDef2(stepId) {
-  var _this6 = this;
+  var _this7 = this;
   var handler = /*#__PURE__*/function () {
-    var _ref25 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(_ref24) {
-      var data, runId, targetStep, inputSchema, payload, action, mergedData, validatedData, finalAction;
+    var _ref28 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(_ref27) {
+      var context, runId, targetStep, payload, action, mergedData, finalAction;
       return _regeneratorRuntime().wrap(function _callee4$(_context4) {
         while (1) switch (_context4.prev = _context4.next) {
           case 0:
-            data = _ref24.data, runId = _ref24.runId;
-            targetStep = _classPrivateFieldLooseBase(_this6, _steps)[_steps].find(function (s) {
-              return s.id === stepId;
-            });
+            context = _ref27.context, runId = _ref27.runId;
+            targetStep = _classPrivateFieldLooseBase(_this7, _steps)[_steps][stepId];
             if (targetStep) {
               _context4.next = 4;
               break;
             }
             throw new Error("Step not found");
           case 4:
-            inputSchema = targetStep.inputSchema, payload = targetStep.payload, action = targetStep.action; // Merge static payload with dynamically resolved variables
+            payload = targetStep.payload, action = targetStep.action; // Merge static payload with dynamically resolved variables
             // Variables take precedence over payload values
-            mergedData = _extends({}, payload, data); // Validate complete input data
-            validatedData = inputSchema ? inputSchema.parse(mergedData) : mergedData; // Only trace if telemetry is available and action exists
-            finalAction = action && _classPrivateFieldLooseBase(_this6, _telemetry)[_telemetry] ? _classPrivateFieldLooseBase(_this6, _telemetry)[_telemetry].traceMethod(action, {
-              spanName: "workflow." + _this6.name + ".action." + stepId
+            mergedData = _extends({}, payload, context); // Only trace if telemetry is available and action exists
+            finalAction = action && _classPrivateFieldLooseBase(_this7, _telemetry)[_telemetry] ? _classPrivateFieldLooseBase(_this7, _telemetry)[_telemetry].traceMethod(action, {
+              spanName: "workflow." + _this7.name + ".action." + stepId
             }) : action;
             if (!finalAction) {
-              _context4.next = 14;
+              _context4.next = 13;
               break;
             }
-            _context4.next = 11;
+            _context4.next = 10;
             return finalAction({
-              data: validatedData,
+              context: mergedData,
               runId: runId
             });
-          case 11:
+          case 10:
             _context4.t0 = _context4.sent;
-            _context4.next = 15;
+            _context4.next = 14;
             break;
-          case 14:
+          case 13:
             _context4.t0 = {};
-          case 15:
+          case 14:
             return _context4.abrupt("return", _context4.t0);
-          case 16:
+          case 15:
           case "end":
             return _context4.stop();
         }
       }, _callee4);
     }));
     return function handler(_x9) {
-      return _ref25.apply(this, arguments);
+      return _ref28.apply(this, arguments);
     };
   }();
   // Only trace handler if telemetry is available
@@ -4667,17 +4690,16 @@ function _makeStepDef2(stepId) {
     spanName: "workflow." + this.name + ".step." + stepId
   }) : handler;
   return {
-    dependsOn: [],
     handler: finalHandler,
     data: {}
   };
 }
 function _makeDelayMap2() {
-  var _this7 = this;
+  var _this8 = this;
   var delayMap = {};
-  _classPrivateFieldLooseBase(this, _steps)[_steps].forEach(function (step) {
-    var _step$retryConfig2, _classPrivateFieldLoo2;
-    delayMap[step.id] = (step == null || (_step$retryConfig2 = step.retryConfig) == null ? void 0 : _step$retryConfig2.delay) || ((_classPrivateFieldLoo2 = _classPrivateFieldLooseBase(_this7, _retryConfig)[_retryConfig]) == null ? void 0 : _classPrivateFieldLoo2.delay) || 1000;
+  Object.keys(_classPrivateFieldLooseBase(this, _steps)[_steps]).forEach(function (stepId) {
+    var _classPrivateFieldLoo3, _classPrivateFieldLoo4;
+    delayMap[stepId] = ((_classPrivateFieldLoo3 = _classPrivateFieldLooseBase(_this8, _steps)[_steps][stepId]) == null || (_classPrivateFieldLoo3 = _classPrivateFieldLoo3.retryConfig) == null ? void 0 : _classPrivateFieldLoo3.delay) || ((_classPrivateFieldLoo4 = _classPrivateFieldLooseBase(_this8, _retryConfig)[_retryConfig]) == null ? void 0 : _classPrivateFieldLoo4.delay) || 1000;
   });
   return delayMap;
 }