@mastra/playground-ui 59.0.0 → 60.0.0-alpha.1

package/dist/domains/workflows/workflow/utils.es.js

@@ -0,0 +1,636 @@
+import { MarkerType } from '@xyflow/react';
+import { getWorkflowMapContext } from './workflow-graph-groups.es.js';
+import { getLayoutedElements } from './workflow-graph-layout.es.js';
+import { WORKFLOW_STEP_NODE_TYPE, unwrapInnerEntry, resolveWorkflowGraphStep } from './workflow-step-node-utils.es.js';
+import { W as WORKFLOW_BOUNDARY_NODE_TYPE } from '../../../types-CvneO3z0.js';
+
+const getWorkflowBoundaryNodeId = (role) => `boundary-${role}`;
+const WORKFLOW_START_NODE_ID = getWorkflowBoundaryNodeId("start");
+const WORKFLOW_END_NODE_ID = getWorkflowBoundaryNodeId("end");
+const getWorkflowNodeId = (stepId) => `node-${stepId}`;
+const getWorkflowConditionNodeId = (conditionId) => `condition-node-${conditionId}`;
+const getWorkflowEdgeId = (source, target) => `edge-${source}-${target}`;
+const formatMappingLabel = (stepId, prevStepIds, nextStepIds) => {
+  if (!stepId.startsWith("mapping_")) {
+    return stepId;
+  }
+  const capitalizeWords = (str) => {
+    return str.split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  };
+  const formatStepName = (id) => {
+    const cleaned = id.replace(/Step$/, "").replace(/[-_]/g, " ").trim();
+    return capitalizeWords(cleaned);
+  };
+  const formatMultipleSteps = (ids, isTarget) => {
+    if (ids.length === 0) return isTarget ? "End" : "Start";
+    const [onlyId] = ids;
+    if (ids.length === 1 && onlyId) return formatStepName(onlyId);
+    return `${ids.length} Steps`;
+  };
+  const fromLabel = formatMultipleSteps(prevStepIds, false);
+  const toLabel = formatMultipleSteps(nextStepIds, true);
+  return `${fromLabel} → ${toLabel} Map`;
+};
+const defaultEdgeOptions = {
+  animated: true,
+  markerEnd: {
+    type: MarkerType.ArrowClosed,
+    width: 20,
+    height: 20,
+    color: "#8e8e8e"
+  }
+};
+const conditionWorkflowStep = (condition) => resolveWorkflowGraphStep({
+  type: "conditional",
+  steps: [],
+  serializedConditions: [condition]
+});
+const getSingleStepFlowId = (flow) => {
+  if ("id" in flow && flow.id !== void 0) return flow.id;
+  if ("step" in flow) {
+    const inner = flow.step;
+    if ("id" in inner) return inner.id;
+    if ("step" in inner) return inner.step.id;
+  }
+  return "";
+};
+const getStepNodeAndEdge = ({
+  stepFlow,
+  xIndex,
+  yIndex,
+  prevNodeIds,
+  prevStepIds,
+  nextStepFlow,
+  condition,
+  allPrevNodeIds
+}) => {
+  let nextNodeIds = [];
+  let nextStepIds = [];
+  if (nextStepFlow?.type === "step" || nextStepFlow?.type === "foreach" || nextStepFlow?.type === "loop") {
+    const nextInner = nextStepFlow.type === "step" ? nextStepFlow.step : unwrapInnerEntry(nextStepFlow.step);
+    const nextStepId = allPrevNodeIds.has(getWorkflowNodeId(nextInner.id)) ? `${nextInner.id}-${yIndex + 1}` : nextInner.id;
+    nextNodeIds = [getWorkflowNodeId(nextStepId)];
+    nextStepIds = [nextInner.id];
+  }
+  if (nextStepFlow?.type === "sleep" || nextStepFlow?.type === "sleepUntil" || nextStepFlow?.type === "agent" || nextStepFlow?.type === "tool" || nextStepFlow?.type === "classifier" || nextStepFlow?.type === "mapping" || nextStepFlow?.type === "workflow") {
+    const nextStepId = allPrevNodeIds.has(getWorkflowNodeId(nextStepFlow.id)) ? `${nextStepFlow.id}-${yIndex + 1}` : nextStepFlow.id;
+    nextNodeIds = [getWorkflowNodeId(nextStepId)];
+    nextStepIds = [nextStepFlow.id];
+  }
+  if (nextStepFlow?.type === "parallel") {
+    nextNodeIds = nextStepFlow?.steps.map((step) => {
+      const stepId = getSingleStepFlowId(step);
+      const nextStepId = allPrevNodeIds.has(getWorkflowNodeId(stepId)) ? `${stepId}-${yIndex + 1}` : stepId;
+      return getWorkflowNodeId(nextStepId);
+    }) || [];
+    nextStepIds = nextStepFlow?.steps.map((step) => getSingleStepFlowId(step)) || [];
+  }
+  if (nextStepFlow?.type === "conditional") {
+    nextNodeIds = nextStepFlow?.serializedConditions.map((cond) => getWorkflowConditionNodeId(cond.id)) || [];
+    nextStepIds = nextStepFlow?.steps?.map((step) => getSingleStepFlowId(step)) || [];
+  }
+  if (stepFlow.type === "step" || stepFlow.type === "foreach") {
+    const innerStep = stepFlow.type === "foreach" ? unwrapInnerEntry(stepFlow.step) : stepFlow.step;
+    const hasGraph = innerStep.component === "WORKFLOW";
+    const rawNodeId = allPrevNodeIds.has(getWorkflowNodeId(innerStep.id)) ? `${innerStep.id}-${yIndex}` : innerStep.id;
+    const nodeId = getWorkflowNodeId(rawNodeId);
+    const conditionNodes = condition ? [
+      {
+        id: getWorkflowConditionNodeId(condition.id),
+        position: { x: xIndex * 300, y: yIndex * 100 },
+        type: WORKFLOW_STEP_NODE_TYPE,
+        data: {
+          label: condition.id,
+          workflowStep: conditionWorkflowStep(condition),
+          nodeRole: "condition",
+          previousStepId: prevStepIds[prevStepIds.length - 1],
+          nextStepId: innerStep.id,
+          withoutTopHandle: !prevNodeIds.length,
+          withoutBottomHandle: !nextNodeIds.length,
+          isLarge: true,
+          conditions: [{ type: "when", fnString: condition.fn }]
+        }
+      }
+    ] : [];
+    const nodes = [
+      ...conditionNodes,
+      {
+        id: nodeId,
+        position: { x: xIndex * 300, y: (yIndex + (condition ? 1 : 0)) * 100 },
+        type: WORKFLOW_STEP_NODE_TYPE,
+        data: {
+          label: formatMappingLabel(innerStep.id, prevStepIds, nextStepIds),
+          workflowStep: resolveWorkflowGraphStep(stepFlow),
+          stepId: innerStep.id,
+          description: innerStep.description,
+          withoutTopHandle: condition ? false : !prevNodeIds.length,
+          withoutBottomHandle: !nextNodeIds.length,
+          stepGraph: hasGraph ? innerStep.serializedStepFlow : void 0,
+          mapConfig: innerStep.mapConfig,
+          canSuspend: innerStep.canSuspend,
+          isForEach: stepFlow.type === "foreach",
+          metadata: innerStep.metadata
+        }
+      }
+    ];
+    const edges = [
+      ...condition ? [
+        ...(prevNodeIds || []).map((prevNodeId, i) => ({
+          id: getWorkflowEdgeId(prevNodeId, getWorkflowConditionNodeId(condition.id)),
+          source: prevNodeId,
+          data: { previousStepId: prevStepIds[i], nextStepId: innerStep.id, conditionNode: true },
+          target: getWorkflowConditionNodeId(condition.id),
+          ...defaultEdgeOptions
+        })),
+        {
+          id: getWorkflowEdgeId(getWorkflowConditionNodeId(condition.id), nodeId),
+          source: getWorkflowConditionNodeId(condition.id),
+          data: {
+            previousStepId: prevStepIds[prevStepIds.length - 1],
+            nextStepId: innerStep.id,
+            conditionNode: true
+          },
+          target: nodeId,
+          ...defaultEdgeOptions
+        }
+      ] : (prevNodeIds || []).map((prevNodeId, i) => ({
+        id: getWorkflowEdgeId(prevNodeId, nodeId),
+        source: prevNodeId,
+        data: { previousStepId: prevStepIds[i], nextStepId: innerStep.id },
+        target: nodeId,
+        ...defaultEdgeOptions
+      }))
+    ];
+    return { nodes, edges, nextPrevNodeIds: [nodeId], nextPrevStepIds: [innerStep.id] };
+  }
+  if (stepFlow.type === "agent" || stepFlow.type === "tool" || stepFlow.type === "classifier" || stepFlow.type === "mapping" || stepFlow.type === "workflow") {
+    const stepId = stepFlow.id;
+    const rawNodeId = allPrevNodeIds.has(getWorkflowNodeId(stepId)) ? `${stepId}-${yIndex}` : stepId;
+    const nodeId = getWorkflowNodeId(rawNodeId);
+    const description = stepFlow.type === "classifier" ? void 0 : stepFlow.description;
+    const label = stepFlow.type === "mapping" ? formatMappingLabel(stepId, prevStepIds, nextStepIds) : stepId;
+    const conditionNodes = condition ? [
+      {
+        id: getWorkflowConditionNodeId(condition.id),
+        position: { x: xIndex * 300, y: yIndex * 100 },
+        type: WORKFLOW_STEP_NODE_TYPE,
+        data: {
+          label: condition.id,
+          workflowStep: conditionWorkflowStep(condition),
+          nodeRole: "condition",
+          previousStepId: prevStepIds[prevStepIds.length - 1],
+          nextStepId: stepId,
+          withoutTopHandle: !prevNodeIds.length,
+          withoutBottomHandle: !nextNodeIds.length,
+          isLarge: true,
+          conditions: [{ type: "when", fnString: condition.fn }]
+        }
+      }
+    ] : [];
+    const nodes = [
+      ...conditionNodes,
+      {
+        id: nodeId,
+        position: { x: xIndex * 300, y: (yIndex + (condition ? 1 : 0)) * 100 },
+        type: WORKFLOW_STEP_NODE_TYPE,
+        data: {
+          label,
+          workflowStep: resolveWorkflowGraphStep(stepFlow),
+          stepId,
+          description,
+          metadata: stepFlow.type === "mapping" ? stepFlow.metadata : void 0,
+          withoutTopHandle: condition ? false : !prevNodeIds.length,
+          withoutBottomHandle: !nextNodeIds.length,
+          mapConfig: stepFlow.type === "mapping" ? stepFlow.mapConfig : void 0,
+          stepGraph: stepFlow.type === "workflow" ? stepFlow.serializedStepFlow : void 0
+        }
+      }
+    ];
+    const edges = [
+      ...condition ? [
+        ...(prevNodeIds || []).map((prevNodeId, i) => ({
+          id: getWorkflowEdgeId(prevNodeId, getWorkflowConditionNodeId(condition.id)),
+          source: prevNodeId,
+          data: { previousStepId: prevStepIds[i], nextStepId: stepId, conditionNode: true },
+          target: getWorkflowConditionNodeId(condition.id),
+          ...defaultEdgeOptions
+        })),
+        {
+          id: getWorkflowEdgeId(getWorkflowConditionNodeId(condition.id), nodeId),
+          source: getWorkflowConditionNodeId(condition.id),
+          data: {
+            previousStepId: prevStepIds[prevStepIds.length - 1],
+            nextStepId: stepId,
+            conditionNode: true
+          },
+          target: nodeId,
+          ...defaultEdgeOptions
+        }
+      ] : (prevNodeIds || []).map((prevNodeId, i) => ({
+        id: getWorkflowEdgeId(prevNodeId, nodeId),
+        source: prevNodeId,
+        data: { previousStepId: prevStepIds[i], nextStepId: stepId },
+        target: nodeId,
+        ...defaultEdgeOptions
+      }))
+    ];
+    return { nodes, edges, nextPrevNodeIds: [nodeId], nextPrevStepIds: [stepId] };
+  }
+  if (stepFlow.type === "sleep" || stepFlow.type === "sleepUntil") {
+    const rawNodeId = allPrevNodeIds.has(getWorkflowNodeId(stepFlow.id)) ? `${stepFlow.id}-${yIndex}` : stepFlow.id;
+    const nodeId = getWorkflowNodeId(rawNodeId);
+    const conditionNodes = condition ? [
+      {
+        id: getWorkflowConditionNodeId(condition.id),
+        position: { x: xIndex * 300, y: yIndex * 100 },
+        type: WORKFLOW_STEP_NODE_TYPE,
+        data: {
+          label: condition.id,
+          workflowStep: conditionWorkflowStep(condition),
+          nodeRole: "condition",
+          previousStepId: prevStepIds[prevStepIds.length - 1],
+          nextStepId: stepFlow.id,
+          withoutTopHandle: false,
+          withoutBottomHandle: !nextNodeIds.length,
+          isLarge: true,
+          conditions: [{ type: "when", fnString: condition.fn }]
+        }
+      }
+    ] : [];
+    const nodes = [
+      ...conditionNodes,
+      {
+        id: nodeId,
+        position: { x: xIndex * 300, y: (yIndex + (condition ? 1 : 0)) * 100 },
+        type: WORKFLOW_STEP_NODE_TYPE,
+        data: {
+          label: stepFlow.id,
+          workflowStep: resolveWorkflowGraphStep(stepFlow),
+          stepId: stepFlow.id,
+          description: stepFlow.description,
+          metadata: stepFlow.metadata,
+          withoutTopHandle: condition ? false : !prevNodeIds.length,
+          withoutBottomHandle: !nextNodeIds.length,
+          ...stepFlow.type === "sleepUntil" ? { date: stepFlow.date } : { duration: stepFlow.duration }
+        }
+      }
+    ];
+    const edges = [
+      ...!prevNodeIds.length ? [] : condition ? [
+        ...prevNodeIds.map((prevNodeId, i) => ({
+          id: getWorkflowEdgeId(prevNodeId, getWorkflowConditionNodeId(condition.id)),
+          source: prevNodeId,
+          data: { previousStepId: prevStepIds[i], nextStepId: stepFlow.id, conditionNode: true },
+          target: getWorkflowConditionNodeId(condition.id),
+          ...defaultEdgeOptions
+        })),
+        {
+          id: getWorkflowEdgeId(getWorkflowConditionNodeId(condition.id), nodeId),
+          source: getWorkflowConditionNodeId(condition.id),
+          data: {
+            previousStepId: prevStepIds[prevStepIds.length - 1],
+            nextStepId: stepFlow.id,
+            conditionNode: true
+          },
+          target: nodeId,
+          ...defaultEdgeOptions
+        }
+      ] : prevNodeIds.map((prevNodeId, i) => ({
+        id: getWorkflowEdgeId(prevNodeId, nodeId),
+        source: prevNodeId,
+        data: { previousStepId: prevStepIds[i], nextStepId: stepFlow.id },
+        target: nodeId,
+        ...defaultEdgeOptions
+      }))
+    ];
+    return { nodes, edges, nextPrevNodeIds: [nodeId], nextPrevStepIds: [stepFlow.id] };
+  }
+  if (stepFlow.type === "loop") {
+    const { serializedCondition, loopType } = stepFlow;
+    const _step = unwrapInnerEntry(stepFlow.step);
+    const rawNodeId = allPrevNodeIds.has(getWorkflowNodeId(_step.id)) ? `${_step.id}-${yIndex}` : _step.id;
+    const nodeId = getWorkflowNodeId(rawNodeId);
+    const rawConditionId = allPrevNodeIds.has(getWorkflowConditionNodeId(serializedCondition.id)) ? `${serializedCondition.id}-${yIndex}` : serializedCondition.id;
+    const conditionNodeId = getWorkflowConditionNodeId(rawConditionId);
+    const nodes = [
+      {
+        id: nodeId,
+        position: { x: xIndex * 300, y: yIndex * 100 },
+        type: WORKFLOW_STEP_NODE_TYPE,
+        data: {
+          label: _step.id,
+          workflowStep: resolveWorkflowGraphStep(stepFlow),
+          stepId: _step.id,
+          description: _step.description,
+          withoutTopHandle: !prevNodeIds.length,
+          withoutBottomHandle: false,
+          stepGraph: _step.component === "WORKFLOW" ? _step.serializedStepFlow : void 0,
+          canSuspend: _step.canSuspend,
+          metadata: _step.metadata
+        }
+      },
+      {
+        id: conditionNodeId,
+        position: { x: xIndex * 300, y: (yIndex + 1) * 100 },
+        type: WORKFLOW_STEP_NODE_TYPE,
+        data: {
+          label: serializedCondition.id,
+          workflowStep: conditionWorkflowStep(serializedCondition),
+          nodeRole: "condition",
+          previousStepId: _step.id,
+          nextStepId: nextStepIds[0],
+          withoutTopHandle: false,
+          withoutBottomHandle: !nextNodeIds.length,
+          isLarge: true,
+          conditions: [{ type: loopType, fnString: serializedCondition.fn }]
+        }
+      }
+    ];
+    const edges = [
+      ...!prevNodeIds.length ? [] : prevNodeIds.map((prevNodeId, i) => ({
+        id: getWorkflowEdgeId(prevNodeId, nodeId),
+        source: prevNodeId,
+        data: { previousStepId: prevStepIds[i], nextStepId: _step.id },
+        target: nodeId,
+        ...defaultEdgeOptions
+      })),
+      {
+        id: getWorkflowEdgeId(nodeId, conditionNodeId),
+        source: nodeId,
+        data: { previousStepId: _step.id, nextStepId: nextStepIds[0] },
+        target: conditionNodeId,
+        ...defaultEdgeOptions
+      }
+    ];
+    return { nodes, edges, nextPrevNodeIds: [conditionNodeId], nextPrevStepIds: [_step.id] };
+  }
+  if (stepFlow.type === "parallel") {
+    let nodes = [];
+    let edges = [];
+    let nextPrevStepIds = [];
+    stepFlow.steps.forEach((_stepFlow, index) => {
+      const {
+        nodes: _nodes,
+        edges: _edges,
+        nextPrevStepIds: _nextPrevStepIds
+      } = getStepNodeAndEdge({
+        stepFlow: _stepFlow,
+        xIndex: index,
+        yIndex,
+        prevNodeIds,
+        prevStepIds,
+        nextStepFlow,
+        allPrevNodeIds
+      });
+      nodes.push(..._nodes);
+      edges.push(..._edges);
+      nextPrevStepIds.push(..._nextPrevStepIds);
+    });
+    const parallelGroup = { id: `parallel:${nodes.map((node) => node.id).join(":")}`, pathCount: stepFlow.steps.length };
+    nodes = nodes.map((node) => ({
+      ...node,
+      data: { ...node.data, isParallel: true, parallelGroup }
+    }));
+    return { nodes, edges, nextPrevNodeIds: nodes.map((node) => node.id), nextPrevStepIds };
+  }
+  if (stepFlow.type === "conditional") {
+    let nodes = [];
+    let edges = [];
+    let nextPrevStepIds = [];
+    stepFlow.steps.forEach((_stepFlow, index) => {
+      const branchCondition = stepFlow.serializedConditions[index];
+      if (!branchCondition) throw new Error("A workflow branch is missing its condition.");
+      const {
+        nodes: _nodes,
+        edges: _edges,
+        nextPrevStepIds: _nextPrevStepIds
+      } = getStepNodeAndEdge({
+        stepFlow: _stepFlow,
+        xIndex: index,
+        yIndex,
+        prevNodeIds,
+        prevStepIds,
+        nextStepFlow,
+        condition: branchCondition,
+        allPrevNodeIds
+      });
+      nodes.push(..._nodes);
+      edges.push(..._edges);
+      nextPrevStepIds.push(..._nextPrevStepIds);
+    });
+    return {
+      nodes,
+      edges,
+      nextPrevNodeIds: nodes.filter(({ data }) => data.nodeRole !== "condition").map((node) => node.id),
+      nextPrevStepIds
+    };
+  }
+  throw new Error("This workflow contains a step type that Studio does not support.");
+};
+const constructNodesAndEdges = ({
+  stepGraph
+}) => {
+  if (!stepGraph) {
+    return { nodes: [], edges: [] };
+  }
+  if (stepGraph.length === 0) {
+    return { nodes: [], edges: [] };
+  }
+  let nodes = [];
+  let edges = [];
+  let prevNodeIds = [];
+  let prevStepIds = [];
+  const allPrevNodeIds = /* @__PURE__ */ new Set();
+  for (const [index, stepFlow] of stepGraph.entries()) {
+    const {
+      nodes: _nodes,
+      edges: _edges,
+      nextPrevNodeIds,
+      nextPrevStepIds
+    } = getStepNodeAndEdge({
+      stepFlow,
+      xIndex: index,
+      yIndex: index,
+      prevNodeIds,
+      prevStepIds,
+      nextStepFlow: index === stepGraph.length - 1 ? void 0 : stepGraph[index + 1],
+      allPrevNodeIds
+    });
+    nodes.push(..._nodes);
+    edges.push(..._edges);
+    prevNodeIds = nextPrevNodeIds;
+    prevStepIds = nextPrevStepIds;
+    for (const node of _nodes) {
+      allPrevNodeIds.add(node.id);
+    }
+  }
+  const edgeTargetIds = new Set(edges.map((edge) => edge.target));
+  const edgeSourceIds = new Set(edges.map((edge) => edge.source));
+  const sourceNodeIds = nodes.filter((node) => !edgeTargetIds.has(node.id)).map((node) => node.id);
+  const terminalNodeIds = nodes.filter((node) => !edgeSourceIds.has(node.id)).map((node) => node.id);
+  const sourceNodeIdSet = new Set(sourceNodeIds);
+  const terminalNodeIdSet = new Set(terminalNodeIds);
+  nodes = nodes.map((node) => ({
+    ...node,
+    data: {
+      ...node.data,
+      mapContext: getWorkflowMapContext(node, nodes, edges),
+      ...sourceNodeIdSet.has(node.id) ? { withoutTopHandle: false } : {},
+      ...terminalNodeIdSet.has(node.id) ? { withoutBottomHandle: false } : {}
+    }
+  }));
+  const graphNodes = [
+    {
+      id: WORKFLOW_START_NODE_ID,
+      position: { x: 0, y: 0 },
+      type: WORKFLOW_BOUNDARY_NODE_TYPE,
+      data: { label: "Start", boundaryRole: "start" }
+    },
+    ...nodes,
+    {
+      id: WORKFLOW_END_NODE_ID,
+      position: { x: 0, y: 0 },
+      type: WORKFLOW_BOUNDARY_NODE_TYPE,
+      data: { label: "End", boundaryRole: "end" }
+    }
+  ];
+  const sourceBoundaryEdges = sourceNodeIds.map((nodeId) => ({
+    id: getWorkflowEdgeId(WORKFLOW_START_NODE_ID, nodeId),
+    source: WORKFLOW_START_NODE_ID,
+    target: nodeId,
+    data: {
+      boundaryPayload: "workflow-input",
+      nextStepId: (() => {
+        const targetNode = graphNodes.find((node) => node.id === nodeId);
+        if (targetNode?.type !== WORKFLOW_STEP_NODE_TYPE) return nodeId;
+        return targetNode?.data.stepId ?? targetNode?.data.nextStepId ?? nodeId;
+      })()
+    },
+    ...defaultEdgeOptions
+  }));
+  const terminalBoundaryEdges = terminalNodeIds.map((nodeId) => ({
+    id: getWorkflowEdgeId(nodeId, WORKFLOW_END_NODE_ID),
+    source: nodeId,
+    target: WORKFLOW_END_NODE_ID,
+    data: { boundaryPayload: "workflow-output" },
+    ...defaultEdgeOptions
+  }));
+  edges = [...sourceBoundaryEdges, ...edges, ...terminalBoundaryEdges];
+  edges = [...new Map(edges.map((edge) => [edge.id, edge])).values()];
+  const { nodes: layoutedNodes, edges: layoutedEdges } = getLayoutedElements(graphNodes, edges);
+  return { nodes: layoutedNodes, edges: layoutedEdges };
+};
+const buildStepsFlow = (edges) => {
+  const predecessors = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    if (!edge.data || edge.data.boundaryPayload) continue;
+    const { nextStepId, previousStepId } = edge.data;
+    if (!nextStepId || !previousStepId) continue;
+    const stepPredecessors = predecessors.get(nextStepId) ?? /* @__PURE__ */ new Set();
+    stepPredecessors.add(previousStepId);
+    predecessors.set(nextStepId, stepPredecessors);
+  }
+  return Object.fromEntries([...predecessors].map(([stepId, stepPredecessors]) => [stepId, [...stepPredecessors]]));
+};
+const buildStepSuccessors = (stepsFlow) => Object.entries(stepsFlow).reduce((acc, [stepId, prevStepIds]) => {
+  for (const prevStepId of prevStepIds) {
+    acc[prevStepId] = [.../* @__PURE__ */ new Set([...acc[prevStepId] || [], stepId])];
+  }
+  return acc;
+}, {});
+const collectGraphStepFlags = (stepGraph) => {
+  const conditionalStepIds = /* @__PURE__ */ new Set();
+  const nestedWorkflowStepIds = /* @__PURE__ */ new Set();
+  const visit = (entry) => {
+    if (!entry) return;
+    if (entry.type === "workflow") {
+      nestedWorkflowStepIds.add(entry.id);
+      return;
+    }
+    if (entry.type === "step" || entry.type === "foreach" || entry.type === "loop") {
+      const inner = entry.type === "step" ? entry.step : unwrapInnerEntry(entry.step);
+      if (inner?.component === "WORKFLOW" && inner?.id) {
+        nestedWorkflowStepIds.add(inner.id);
+      }
+    }
+    if (entry.type === "conditional") {
+      for (const child of entry.steps) {
+        conditionalStepIds.add(getSingleStepFlowId(child));
+        visit(child);
+      }
+    }
+    if (entry.type === "parallel") {
+      for (const child of entry.steps) {
+        visit(child);
+      }
+    }
+  };
+  for (const entry of stepGraph ?? []) {
+    visit(entry);
+  }
+  return { conditionalStepIds, nestedWorkflowStepIds };
+};
+const isBranchArmBypassed = ({
+  stepId,
+  conditionalStepIds,
+  stepSuccessors,
+  stepsFlow,
+  steps
+}) => {
+  if (!conditionalStepIds.has(stepId)) return false;
+  if (steps?.[stepId]?.status === "skipped") return true;
+  if (steps?.[stepId]?.status !== void 0) return false;
+  const hasSucceeded = (candidateId) => steps?.[candidateId]?.status === "success";
+  const siblingArmsOn = (successorId) => (stepsFlow[successorId] ?? []).filter((armId) => armId !== stepId);
+  return (stepSuccessors[stepId] ?? []).some(
+    (successorId) => hasSucceeded(successorId) || siblingArmsOn(successorId).some(hasSucceeded)
+  );
+};
+const selectNextStepKey = ({
+  stepNodesInOrder,
+  isStepSuccess,
+  isStepBypassed
+}) => stepNodesInOrder.find((stepId) => !isStepSuccess(stepId) && !isStepBypassed(stepId));
+const isLastRunnableStep = ({
+  nextStepKey,
+  stepNodesInOrder,
+  isStepSuccess,
+  isStepBypassed
+}) => {
+  if (!nextStepKey) return false;
+  const nextIndex = stepNodesInOrder.indexOf(nextStepKey);
+  return stepNodesInOrder.slice(nextIndex + 1).every((stepId) => isStepSuccess(stepId) || isStepBypassed(stepId));
+};
+const allPredecessorsResolved = (previousSteps, steps, isBypassed = () => false) => previousSteps.every((stepId) => steps?.[stepId]?.status === "success" || isBypassed(stepId));
+const findFocusNode = (nodes, stepId) => nodes.find((node) => (node.data?.stepId ?? node.data?.label) === stepId);
+const buildNextStepInput = ({
+  nextStepKey,
+  stepsFlow,
+  steps,
+  isStepBypassed = () => false
+}) => {
+  if (!nextStepKey) return void 0;
+  const previousSteps = stepsFlow?.[nextStepKey] ?? [];
+  if (previousSteps.length === 0) return void 0;
+  if (previousSteps.length > 1) {
+    if (!allPredecessorsResolved(previousSteps, steps, isStepBypassed)) return void 0;
+    return {
+      hasMultiSteps: true,
+      input: previousSteps.filter((stepId) => steps?.[stepId]?.status === "success").reduce((acc, stepId) => {
+        acc[stepId] = steps?.[stepId]?.output;
+        return acc;
+      }, {})
+    };
+  }
+  const prevStepId = previousSteps[0];
+  if (prevStepId && steps?.[prevStepId]?.status === "success") {
+    return {
+      hasMultiSteps: false,
+      input: steps?.[prevStepId]?.output
+    };
+  }
+  return void 0;
+};
+
+export { allPredecessorsResolved, buildNextStepInput, buildStepSuccessors, buildStepsFlow, collectGraphStepFlags, constructNodesAndEdges, findFocusNode, isBranchArmBypassed, isLastRunnableStep, selectNextStepKey };
+//# sourceMappingURL=utils.es.js.map