@useparagon/core 0.0.1-canary.1

package/src/stateMachine/stateMachine.utils.ts

@@ -0,0 +1,733 @@
+import { Choice, ConditionalStep } from '../steps/library/conditional';
+import { FanOutStep } from '../steps/library/fanout';
+import { IStep, StepMap, StepType } from '../steps/step.interface';
+import {
+  concatAndDedupeStepLists,
+  isConditional,
+  isFanout,
+  isStepInStepList,
+  isTrigger,
+} from '../steps/step.utils';
+import { IWorkflow } from '../workflow/workflow.interface';
+import { EMPTY_STATE_MACHINE } from './stateMachine.constants';
+import {
+  StateMachine,
+  Sequence,
+  SequenceEdge,
+  SequenceEdgeType,
+  SequenceMap,
+  SequenceType,
+  StepEdge,
+} from './stateMachine.interface';
+
+/**
+ * gets the last step within a sequence
+ *
+ * @param sequence
+ * @param stateMachine
+ * @returns
+ */
+export function getLastStepInSequence(
+  sequence: Sequence,
+  stateMachine: StateMachine,
+): IStep | undefined {
+  const nextSequenceEdge: SequenceEdge | undefined =
+    sequence.sequenceEdges.find((edge: SequenceEdge) => edge.type === 'NEXT');
+  const nextSequence = stateMachine.sequenceMap[nextSequenceEdge?.to || ''];
+  if (nextSequence && nextSequence.stepIds.length > 0) {
+    return getLastStepInSequence(nextSequence, stateMachine);
+  }
+  return stateMachine.stepMap[sequence.stepIds[sequence.stepIds.length - 1]];
+}
+
+/**
+ * creates a sequence and adds it to the `sequence` array provided
+ * which is being used as a store to keep track of sequences created
+ *
+ * @param withStep
+ * @param sequences
+ * @param type
+ * @returns
+ */
+function createSequence(
+  withStep: IStep | undefined,
+  sequences: Sequence[],
+  type: SequenceType,
+): Sequence {
+  const sequence: Sequence = {
+    id: `sequence-${sequences.length}`,
+    start: withStep?.id,
+    stepIds: withStep ? [withStep.id] : [],
+    stepEdges: [],
+    sequenceEdges: [],
+    type,
+    conditionalBranchWidth: 0,
+  };
+  sequences.push(sequence);
+  return sequence;
+}
+
+/**
+ * recursively creates the sequences in a state machine;
+ * populate them with their steps
+ *
+ * @param step
+ * @param sequence
+ * @param stepMap
+ * @param sequences
+ * @param traversed
+ * @param conditionalBranchWidth
+ * @returns
+ */
+function traverseSteps(
+  step: IStep,
+  sequence: Sequence,
+  stepMap: StepMap,
+  sequences: Sequence[],
+  traversed: string[],
+  conditionalBranchWidth: number = 0,
+): number {
+  let maxConditionalBranchWidth: number = conditionalBranchWidth;
+  let nextStepId: string | undefined | null = step?.next ?? null;
+  let nextStep: IStep | undefined = nextStepId
+    ? stepMap[nextStepId]
+    : undefined;
+  let choice: Choice;
+  let newSequence: Sequence;
+  let newSequenceEdge: SequenceEdge;
+  const newStepEdge: StepEdge = {
+    from: step.id,
+    to: nextStepId,
+  };
+
+  if (traversed.includes(step.id)) {
+    return conditionalBranchWidth;
+  }
+  traversed.push(step.id);
+  sequence.stepEdges.push(newStepEdge);
+
+  if (nextStep && !isConditional(step) && !isFanout(step)) {
+    if (isTrigger(step)) {
+      // Create separate sequence for steps after the trigger
+      newSequence = createSequence(nextStep, sequences, SequenceType.MAIN);
+      sequence.sequenceEdges.push({
+        type: SequenceEdgeType.NEXT,
+        from: sequence.id,
+        to: newSequence.id,
+      });
+      traverseSteps(nextStep, newSequence, stepMap, sequences, traversed);
+    } else if (isConditional(nextStep) || isFanout(nextStep)) {
+      // Create separate sequence for a conditional step
+      newSequence = createSequence(nextStep, sequences, sequence.type);
+      sequence.sequenceEdges.push({
+        type: SequenceEdgeType.NEXT,
+        from: sequence.id,
+        to: newSequence.id,
+      });
+      conditionalBranchWidth += traverseSteps(
+        nextStep,
+        newSequence,
+        stepMap,
+        sequences,
+        traversed,
+      );
+    } else {
+      // Add this step to the current sequence
+      sequence.stepIds.push(nextStepId!);
+      conditionalBranchWidth = Math.max(
+        traverseSteps(nextStep, sequence, stepMap, sequences, traversed),
+        conditionalBranchWidth,
+      );
+    }
+  }
+
+  if (isConditional(step)) {
+    conditionalBranchWidth += 1;
+    // iterate through each choice in the step; create a new sequence and add the step to it
+    let i: number = 0;
+    const choices: Choice[] =
+      (step as ConditionalStep)?.parameters?.choices || [];
+    while (i < choices.length) {
+      choice = choices[i];
+      nextStepId = choice.next;
+      nextStep = nextStepId ? stepMap[nextStepId] : undefined;
+      newSequence = createSequence(nextStep, sequences, SequenceType.BRANCH);
+      newSequenceEdge = {
+        type: SequenceEdgeType.BRANCH,
+        from: sequence.id,
+        to: newSequence.id,
+      };
+      sequence.stepEdges.push({
+        label: choice.label,
+        from: step.id,
+        to: nextStepId,
+      });
+      sequence.sequenceEdges.push(newSequenceEdge);
+      if (nextStep) {
+        conditionalBranchWidth += traverseSteps(
+          nextStep,
+          newSequence,
+          stepMap,
+          sequences,
+          traversed,
+        );
+      }
+      i++;
+    }
+
+    // Create separate sequence for resolved condition
+    nextStepId = step.next ?? null;
+    nextStep = stepMap[nextStepId || ''];
+    newSequence = createSequence(nextStep, sequences, SequenceType.MAIN);
+    sequence.sequenceEdges.push({
+      type: SequenceEdgeType.NEXT,
+      from: sequence.id,
+      to: newSequence.id,
+    });
+    if (nextStep) {
+      maxConditionalBranchWidth = Math.max(
+        traverseSteps(nextStep, newSequence, stepMap, sequences, traversed),
+        conditionalBranchWidth,
+      );
+    } else {
+      maxConditionalBranchWidth = Math.max(
+        maxConditionalBranchWidth,
+        conditionalBranchWidth,
+      );
+    }
+
+    sequence.conditionalBranchWidth = conditionalBranchWidth;
+  } else if (isFanout(step)) {
+    sequence.conditionalBranchWidth = 0.5;
+    conditionalBranchWidth += 0.5;
+
+    nextStepId = step.parameters.nextToIterate;
+    nextStep = stepMap[nextStepId || ''];
+    newSequence = createSequence(nextStep, sequences, SequenceType.FANOUT);
+    sequence.sequenceEdges.push({
+      type: SequenceEdgeType.FANOUT,
+      from: sequence.id,
+      to: newSequence.id,
+    });
+    if (nextStep) {
+      sequence.conditionalBranchWidth = Math.max(
+        traverseSteps(nextStep, newSequence, stepMap, sequences, traversed),
+        sequence.conditionalBranchWidth,
+      );
+    }
+
+    nextStep = stepMap[step.next || ''];
+    newSequence = createSequence(nextStep, sequences, SequenceType.MAIN);
+    sequence.sequenceEdges.push({
+      type: SequenceEdgeType.NEXT,
+      from: sequence.id,
+      to: newSequence.id,
+    });
+    if (nextStep) {
+      maxConditionalBranchWidth = Math.max(
+        traverseSteps(nextStep, newSequence, stepMap, sequences, traversed),
+        conditionalBranchWidth,
+      );
+    }
+  }
+
+  return Math.max(maxConditionalBranchWidth, conditionalBranchWidth);
+}
+
+/**
+ * ensures that a state machine is valid
+ *
+ * @param stateMachine the state machine to validate
+ */
+function verifyStateMachine(stateMachine: StateMachine): void {
+  const steps: IStep[] = Object.values(stateMachine.stepMap);
+  let message: string;
+
+  for (const step of steps) {
+    // ensure no step is pointing to itself
+    if (step.next === step.id) {
+      message =
+        "StateMachine invalid: step's 'next' property is pointing to itself.";
+      throw new Error(message);
+    }
+
+    const parentSteps: IStep[] = getUpstreamSteps(step.id, stateMachine);
+    // TODO: uncomment this check to ensure no ghost steps are in the state machine
+    // ensure no dangling (ghost) steps
+    // if (!parentSteps.length && !isTrigger(step)) {
+    //   message = 'StateMachine invalid: step has no parent steps.';
+    //   danger(message, {
+    //     stepId: step.id,
+    //     workflowId: step.workflowId,
+    //   });
+    //   throw Error(message);
+    // }
+
+    // ensure no cyclical workflows (step pointing to a parent step)
+    for (const parentStep of parentSteps) {
+      if (step.next === parentStep.id) {
+        message = 'StateMachine invalid: Cyclical workflow detected.';
+        // TODO: once apps support importing same shared logger on dashboard + other services,
+        // uncomment this to help debugging
+        // error(message, {
+        //   stepId: step.id,
+        //   cyclicalStepId: parentStep.id,
+        //   workflowId: step.workflowId,
+        //   stateMachine: stateMachine,
+        // });
+        throw new Error(message);
+      }
+    }
+  }
+}
+
+/**
+ * recursively traverses a state machine and calls a function on each sequence
+ *
+ * @param stateMachine
+ * @param sequenceVisitor
+ * @param currentSequenceId
+ */
+export function traverseStateMachineBySequence(
+  stateMachine: StateMachine,
+  sequenceVisitor: (sequence: Sequence) => void,
+  currentSequenceId: string = stateMachine.start,
+): void {
+  const currentSequence = stateMachine.sequenceMap[currentSequenceId];
+  sequenceVisitor(currentSequence);
+  currentSequence.sequenceEdges.forEach(({ to }: SequenceEdge) =>
+    traverseStateMachineBySequence(stateMachine, sequenceVisitor, to),
+  );
+}
+
+/**
+ * given a step, it finds the step before it in the workflow
+ *
+ * @param stepsOrWorkflow
+ * @param step
+ * @param traversed
+ * @returns
+ */
+export function getStepBefore(
+  stepsOrWorkflow: IStep[] | IWorkflow,
+  step: IStep,
+  traversed: IStep[] = [],
+): IStep | undefined {
+  if (!Array.isArray(stepsOrWorkflow)) {
+    stepsOrWorkflow = stepsOrWorkflow.steps;
+  }
+  return stepsOrWorkflow.find(
+    (s: IStep) =>
+      !traversed.filter((t: IStep) => t.id === s.id).length &&
+      (s.next === step.id ||
+        (s.type === StepType.IFELSE &&
+          s.parameters?.choices?.find(
+            (choice: Choice) => choice.next === step.id,
+          )) ||
+        (s.type === StepType.MAP && s.next === step.id) ||
+        (s.type === StepType.MAP && s.parameters.nextToIterate === step.id)),
+  );
+}
+
+export function getUpstreamSteps(
+  stepId: string,
+  stateMachine: StateMachine,
+): IStep[] {
+  if (!stateMachine.stepMap[stepId]) {
+    return [];
+  }
+
+  // the reason this is within `getUpstreamSteps` is so we can
+  // recursively call it for different paths;
+  // also, we need it this way so this inner function can update the outer `steps` function
+  function recurseUp(recurseStartStep: IStep | undefined): void {
+    let currentStep: IStep | undefined = recurseStartStep;
+
+    // we want to save the trigger step for last so at the end when we reverse it
+    // it's first in the list
+    while (
+      currentStep &&
+      currentStep.id !== triggerStep?.id &&
+      !isStepInStepList(currentStep, upstreamSteps)
+    ) {
+      if (
+        stepId !== currentStep.id &&
+        isConditional(currentStep) &&
+        !isStepInConditional(
+          initialStep,
+          currentStep as ConditionalStep,
+          stateMachine,
+        )
+      ) {
+        // in this case, we've traversed up to a conditional
+        // however, the initial step isn't in either branch of the conditional
+        // this means all the steps on both sides of the conditional are upstream of the initial step
+        // so we need to recurse down both paths to add them
+        const downstreamSteps: IStep[] = getDownstreamSteps(
+          currentStep.id,
+          stateMachine,
+          stepId,
+        ).reverse();
+        concatAndDedupeStepLists(upstreamSteps, downstreamSteps, false);
+      } else if (
+        stepId !== currentStep.id &&
+        isFanout(currentStep) &&
+        !isStepInFanout(initialStep, currentStep as FanOutStep, stateMachine)
+      ) {
+        // in this case, we've traversed up to a fanout that the current step is not in
+        // since the current step isn't within the fanout, the fanout has steps we haven't traversed
+        // so we need to recurse down the fanout to add them
+        const downstreamSteps: IStep[] = getDownstreamSteps(
+          currentStep.id,
+          stateMachine,
+          stepId,
+        ).reverse();
+        concatAndDedupeStepLists(upstreamSteps, downstreamSteps, false);
+      }
+      upstreamSteps.push(currentStep);
+
+      currentStep = getStepBefore(
+        workflowSteps,
+        stateMachine.stepMap[currentStep.id],
+        upstreamSteps,
+      );
+    }
+  }
+
+  const initialStep: IStep = stateMachine.stepMap[stepId];
+  const upstreamSteps: IStep[] = [];
+  const allSteps: IStep[] = Object.values(stateMachine.stepMap);
+  const triggerStep: IStep | undefined = allSteps.find(isTrigger);
+  const workflowSteps: IStep[] = triggerStep
+    ? getDownstreamSteps(triggerStep.id, stateMachine)
+    : allSteps;
+
+  recurseUp(initialStep);
+
+  if (triggerStep && !isStepInStepList(triggerStep, upstreamSteps)) {
+    upstreamSteps.push(triggerStep);
+  }
+
+  upstreamSteps.reverse();
+
+  return upstreamSteps.filter((s: IStep) => s.id !== stepId);
+}
+
+/**
+ * given a step id and a state machine, it returns an array of steps that are downstream of the step
+ *
+ * @param stepId
+ * @param stateMachine
+ * @param stopId if provided, traversing stops upon reaching this step
+ * @returns
+ */
+export function getDownstreamSteps(
+  stepId: string,
+  stateMachine: StateMachine,
+  stopId: string | null = null,
+): IStep[] {
+  if (!stateMachine.stepMap[stepId]) {
+    return [];
+  }
+
+  // the reason this is within `getUpstreamSteps` is so we can
+  // recursively call it for different paths while tracking the cached state
+  // as well as modify the final result
+  function recurseDown(initialStep: IStep | undefined): void {
+    let currentStep: IStep | undefined = initialStep;
+    while (
+      currentStep &&
+      // currentStep.id !== stopId &&
+      !isStepInStepList(currentStep, downstreamSteps)
+    ) {
+      downstreamSteps.push(currentStep);
+
+      if (isConditional(currentStep)) {
+        // if the step is a conditional, then we need to recurse down two separate paths
+        // we're not going to exit though because the conditional step may also have a `.next` step
+        const conditionalStep: ConditionalStep = currentStep as ConditionalStep;
+
+        const choiceId0: string | null | undefined =
+          conditionalStep.parameters?.choices[0].next;
+        choiceId0 && recurseDown(stateMachine.stepMap[choiceId0]);
+
+        const choiceId1: string | null | undefined =
+          conditionalStep.parameters?.choices[1].next;
+        choiceId1 && recurseDown(stateMachine.stepMap[choiceId1]);
+      } else if (isFanout(currentStep)) {
+        // if the step is a fanout, then we need to recurse down its `.nextToIterate`
+        // we're not going to exit though because the fanout step may also have a `.next` step
+        const nextId: string | null =
+          (currentStep as FanOutStep).parameters.nextToIterate ?? null;
+        nextId && recurseDown(stateMachine.stepMap[nextId]);
+      }
+
+      currentStep = currentStep.next
+        ? stateMachine.stepMap[currentStep.next]
+        : undefined;
+      if (currentStep && currentStep.id === stopId) {
+        break;
+      }
+    }
+  }
+
+  const initialStep: IStep = stateMachine.stepMap[stepId];
+  const downstreamSteps: IStep[] = [];
+
+  recurseDown(initialStep);
+
+  // if there's a requested stopping point for this method,
+  // then we need to get the downstream steps of that stopping point
+  // and filter those out of the returned items
+  // this is because a workflow can have multiple paths
+  // and the steps under the requested stopping point may have been traversed
+  // by a different path in which the stopping point is not on,
+  // such as a workflow with conditionals or fanouts
+  const filterStepIds: string[] = [
+    stateMachine.stepMap[stepId],
+    ...(stopId ? getDownstreamSteps(stopId, stateMachine) : []),
+  ].map((s: IStep) => s.id);
+  return downstreamSteps.filter((s: IStep) => !filterStepIds.includes(s.id));
+}
+
+/**
+ * given a step, a conditional step, and a state machine,
+ * it determines if the step is contained within the conditional within the state machine
+ *
+ * @param step
+ * @param conditional
+ * @param stateMachine
+ * @returns
+ */
+export function isStepInConditional(
+  step: IStep,
+  conditional: ConditionalStep,
+  stateMachine: StateMachine,
+): boolean {
+  if (step.id === conditional.id) {
+    return false;
+  }
+
+  const downstreamSteps: IStep[] = getDownstreamSteps(
+    conditional.id,
+    stateMachine,
+    conditional.next,
+  );
+  const result: boolean =
+    downstreamSteps.filter((s: IStep) => s.id === step.id).length > 0;
+  return result;
+}
+
+/**
+ * given a step, a fanout step, and a state machine,
+ * it determines if the step is contained within the fanout within the state machine
+ *
+ * @param step
+ * @param mapStep
+ * @param stateMachine
+ * @returns
+ */
+export function isStepInFanout(
+  step: IStep,
+  mapStep: FanOutStep,
+  stateMachine: StateMachine,
+): boolean {
+  if (step.id === mapStep.id) {
+    return true;
+  }
+
+  const downstreamSteps: IStep[] = getDownstreamSteps(
+    mapStep.id,
+    stateMachine,
+    mapStep.next,
+  );
+  const result: boolean =
+    downstreamSteps.filter((s: IStep) => s.id === step.id).length > 0;
+  return result;
+}
+
+/**
+ * removes cyclical referenes, unused steps
+ *
+ * @param stateMachine the state machine to validate
+ */
+export function sanitizeStateMachine(stateMachine: StateMachine): StateMachine {
+  // remove unused steps from state machine
+  if (!stateMachine.unusedSteps) {
+    stateMachine.unusedSteps = [];
+  }
+
+  for (const stepId of stateMachine.unusedSteps) {
+    for (const step of Object.values(stateMachine.stepMap)) {
+      if (stepId === step.id) {
+        delete stateMachine.stepMap[step.id];
+      }
+    }
+  }
+
+  const allSteps: IStep[] = Object.values(stateMachine.stepMap);
+  const triggerStep = allSteps.find(isTrigger);
+
+  // TODO(PARA-1245): #test write test to ensure step never points to itself or parent step
+  const steps: IStep[] = triggerStep
+    ? getDownstreamSteps(triggerStep.id, stateMachine)
+    : allSteps;
+
+  for (const step of steps) {
+    // ensure steps aren't pointing to itself
+    if (step.id === step.next) {
+      stateMachine.stepMap[step.id].next = null;
+    }
+
+    // ensure next step exists
+    if (step.next && !stateMachine.stepMap[step.next]) {
+      stateMachine.stepMap[step.id].next = null;
+    }
+
+    // if a fanout but "nextToIterate" is set but doesn't exist in the state machine,
+    // set it to undefined
+    if (
+      isFanout(step) &&
+      step.parameters.nextToIterate &&
+      !stateMachine.stepMap[step.parameters.nextToIterate]
+    ) {
+      (stateMachine.stepMap[step.id] as FanOutStep).parameters.nextToIterate =
+        null;
+    }
+
+    // if a conditional and a choice's next is set but doesn't exist in the state machine,
+    // set it to undefined
+    if (isConditional(step)) {
+      let index: number = -1;
+      for (const choice of (step as ConditionalStep).parameters.choices) {
+        index += 1;
+        if (choice.next && !stateMachine.stepMap[choice.next]) {
+          (stateMachine.stepMap[step.id] as ConditionalStep).parameters.choices[
+            index
+          ].next = null;
+        }
+      }
+    }
+
+    // ensure no cyclical workflows (step pointing to a parent step)
+    const parentSteps: IStep[] = getUpstreamSteps(step.id, stateMachine);
+    for (const parentStep of parentSteps) {
+      if (step.next === parentStep.id && step.id !== parentStep.id) {
+        // TODO: once apps support importing same shared logger on dashboard + other services,
+        // uncomment this to help debugging
+        // warn('detected cyclical step', {
+        //   stepId: step.id,
+        //   cyclicalStepId: parentStep.id,
+        //   workflowId: step.workflowId,
+        //   stateMachine: stateMachine,
+        // });
+        stateMachine.stepMap[step.id].next = null;
+      }
+    }
+
+    // ensure no step is pointing to itself
+    if (step.next === step.id) {
+      stateMachine.stepMap[step.id].next = null;
+    }
+  }
+
+  return stateMachine;
+}
+
+/**
+ * Creates a state machine representation of a workflow or workflow fragment
+ * from an array of IStep objects.
+ *
+ * @param steps IStep entities to create a state machine representation from
+ * @param connectConditionalNextSteps If true, sets `.next` properties of the last steps
+ * of conditional branches to the nearest resolving step
+ * @param startStepId If specified, forces the state machine representation to begin at
+ * this step, even if it's not a trigger-type step
+ */
+export function workflowStepsToStateMachine(
+  steps: IStep[],
+  connectConditionalNextSteps: boolean = false,
+  startStepId?: string,
+): StateMachine {
+  if (steps.length === 0) {
+    return EMPTY_STATE_MACHINE;
+  }
+
+  const stepMap: StepMap = {};
+  steps.forEach((step: IStep) => (stepMap[step.id] = step));
+
+  // get the first step;
+  // initialize the first sequence
+  const sequences: Sequence[] = [];
+  const traversedSteps: string[] = [];
+  const triggerStep: IStep | undefined = steps.find(isTrigger);
+  if (!triggerStep) {
+    throw new Error('Trigger step not found');
+  }
+
+  createSequence(triggerStep, sequences, SequenceType.TRIGGER);
+  traverseSteps(triggerStep, sequences[0], stepMap, sequences, traversedSteps);
+
+  const sequenceMap: SequenceMap = {};
+  sequences.forEach(
+    (sequence: Sequence) => (sequenceMap[sequence.id] = sequence),
+  );
+  const stateMachine: StateMachine = {
+    stepMap,
+    sequenceMap,
+    start: sequences[0].id,
+    activeStepId: startStepId ? startStepId : triggerStep.id,
+    finalStepId:
+      startStepId && startStepId !== triggerStep.id ? startStepId : undefined,
+    unusedSteps: steps
+      .map((step: IStep) => step.id)
+      .filter((id: string) => !traversedSteps.includes(id)),
+  };
+
+  if (connectConditionalNextSteps) {
+    let lastNextFromConditional: string | null = null;
+    const visitedConditionalIds: string[] = [];
+    const lastStep = getLastStepInSequence(
+      stateMachine.sequenceMap[stateMachine.start],
+      stateMachine,
+    );
+    traverseStateMachineBySequence(stateMachine, (sequence: Sequence) => {
+      if (
+        sequence.stepIds.length === 1 &&
+        stateMachine.stepMap[sequence.stepIds[0]].type === StepType.IFELSE
+      ) {
+        const conditionalStep = stateMachine.stepMap[sequence.stepIds[0]];
+        if (visitedConditionalIds.includes(conditionalStep.id)) {
+          return;
+        }
+        if (
+          !conditionalStep.next &&
+          lastStep?.id !== conditionalStep.id &&
+          conditionalStep.id !== lastNextFromConditional
+        ) {
+          conditionalStep.next = lastNextFromConditional;
+        }
+        lastNextFromConditional = conditionalStep.next;
+
+        const branches = sequence.sequenceEdges.filter(
+          (edge: SequenceEdge) => edge.type === SequenceEdgeType.BRANCH,
+        );
+        branches.forEach(({ to }: SequenceEdge) => {
+          const lastStep = getLastStepInSequence(
+            stateMachine.sequenceMap[to],
+            stateMachine,
+          );
+          if (lastStep && lastStep.id !== conditionalStep.next) {
+            lastStep.next = conditionalStep.next;
+          }
+        });
+        visitedConditionalIds.push(conditionalStep.id);
+      }
+    });
+  }
+
+  const finalStateMachine: StateMachine = sanitizeStateMachine(stateMachine);
+  verifyStateMachine(finalStateMachine);
+
+  return finalStateMachine;
+}