@open-mercato/core 0.7.1-develop.7193.1.910a5b0a1e → 0.7.1-develop.7194.1.ab4fc81f82

package/dist/modules/workflows/lib/graph-utils.js

@@ -1,4 +1,43 @@
-function graphToDefinition(nodes, edges, options = {}) {
+import dagre from "@dagrejs/dagre";
+import { isCompensationGhostEdge } from "./compensation-ghosts.js";
+import { isDataMappingEdge } from "./data-edge-mapping.js";
+import { isAnnotationNode } from "./editor-annotations.js";
+import { isTriggerEdge, isTriggerNode } from "./trigger-node.js";
+import { buildWorkflowRouteEdge } from "./route-edge.js";
+import {
+  findRouteKindDescriptor,
+  resolveEdgeRouteKind
+} from "./route-kinds.js";
+import {
+  NODE_DESCRIPTION_HEIGHT,
+  NODE_HEIGHT,
+  NODE_OUTCOME_FOOTER_CHROME_HEIGHT,
+  NODE_OUTCOME_ROW_HEIGHT,
+  NODE_MAX_WIDTH,
+  NODE_MIN_WIDTH,
+  TERMINAL_NODE_HEIGHT,
+  TERMINAL_NODE_MIN_WIDTH
+} from "./node-geometry.js";
+const USER_TASK_INSPECTOR_KEYS = [
+  "instructions",
+  "entityBindings",
+  "priority",
+  "deadline",
+  "reminders",
+  "onBreach",
+  "decisions",
+  "editablePrefilled",
+  // The §7.1 portal discriminator. Listing it here is what makes it survive a
+  // Studio save at all: before, a definition carrying `assigneeKind: 'customer'`
+  // (authorable only through the Code view) was rebuilt from the fixed keys
+  // above and the portal addressing was silently downgraded to backoffice.
+  "assigneeKind"
+];
+function graphToDefinition(allNodes, edges, options = {}) {
+  const nodes = allNodes.filter((node) => !isAnnotationNode(node) && !isTriggerNode(node));
+  const annotationIds = new Set(
+    allNodes.filter((node) => isAnnotationNode(node) || isTriggerNode(node)).map((node) => node.id)
+  );
   const steps = nodes.map((node) => {
     const step = {
       stepId: node.id,
@@ -36,6 +75,10 @@ function graphToDefinition(nodes, edges, options = {}) {
       if (node.data.escalationRules || node.data.userTaskConfig?.escalationRules) {
         step.userTaskConfig.escalationRules = node.data.escalationRules || node.data.userTaskConfig.escalationRules;
       }
+      for (const key of USER_TASK_INSPECTOR_KEYS) {
+        const authored = node.data[key] ?? node.data.userTaskConfig?.[key];
+        if (authored !== void 0) step.userTaskConfig[key] = authored;
+      }
     }
     if (node.type === "waitForSignal" && node.data.signalConfig) {
       step.signalConfig = node.data.signalConfig;
@@ -43,9 +86,32 @@ function graphToDefinition(nodes, edges, options = {}) {
     if (node.type === "automated" && node.data.activities) {
       step.activities = node.data.activities;
     }
+    if (node.type === "invokeAgent") {
+      if (node.data.activities) {
+        step.activities = node.data.activities;
+      }
+      if (node.data.signalConfig) {
+        step.signalConfig = node.data.signalConfig;
+      }
+    }
     if (node.type === "start" && node.data.preConditions && node.data.preConditions.length > 0) {
       step.preConditions = node.data.preConditions;
     }
+    if (node.data.errorDirective) {
+      step.errorDirective = node.data.errorDirective;
+    }
+    const stepMetadata = {
+      ...node.data.stepMetadata && typeof node.data.stepMetadata === "object" ? node.data.stepMetadata : {}
+    };
+    const unmappedConfig = node.data.unmappedConfig;
+    if (unmappedConfig && typeof unmappedConfig === "object" && Object.keys(unmappedConfig).length > 0) {
+      stepMetadata.unmappedConfig = unmappedConfig;
+    } else {
+      delete stepMetadata.unmappedConfig;
+    }
+    if (Object.keys(stepMetadata).length > 0) {
+      step.metadata = stepMetadata;
+    }
     if (options.includePositions && node.position) {
       step._editorPosition = {
         x: node.position.x,
@@ -54,7 +120,7 @@ function graphToDefinition(nodes, edges, options = {}) {
     }
     return step;
   });
-  const transitions = edges.map((edge) => {
+  const transitions = edges.filter((edge) => !isDataMappingEdge(edge) && !isCompensationGhostEdge(edge) && !isTriggerEdge(edge) && !annotationIds.has(edge.source) && !annotationIds.has(edge.target)).map((edge) => {
     const edgeData = edge.data;
     const transition = {
       transitionId: edge.id,
@@ -68,6 +134,11 @@ function graphToDefinition(nodes, edges, options = {}) {
     if (edgeData?.priority !== void 0) {
       transition.priority = edgeData.priority;
     }
+    const routeKind = resolveEdgeRouteKind(edgeData?.kind, edge.sourceHandle);
+    if (routeKind) {
+      transition.kind = routeKind.kind;
+      Object.assign(transition, routeKind.discriminatorFields(edge));
+    }
     if (edgeData?.continueOnActivityFailure !== void 0) {
       transition.continueOnActivityFailure = edgeData.continueOnActivityFailure;
     }
@@ -77,6 +148,9 @@ function graphToDefinition(nodes, edges, options = {}) {
     if (edgeData?.postConditions && edgeData.postConditions.length > 0) {
       transition.postConditions = edgeData.postConditions;
     }
+    if (edgeData?.condition !== void 0 && edgeData.condition !== null) {
+      transition.condition = edgeData.condition;
+    }
     if (edgeData?.activities && edgeData.activities.length > 0) {
       transition.activities = edgeData.activities.map((activity) => ({
         activityId: activity.activityId,
@@ -87,9 +161,13 @@ function graphToDefinition(nodes, edges, options = {}) {
         ...activity.async !== void 0 && { async: activity.async },
         ...activity.timeout && { timeout: activity.timeout },
         ...activity.retryPolicy && { retryPolicy: activity.retryPolicy },
-        ...activity.compensate !== void 0 && { compensate: activity.compensate }
+        ...activity.compensate !== void 0 && { compensate: activity.compensate },
+        // Saga compensation (`compensation.activityId`) is what the canvas'
+        // compensation ghosts render and what `lib/compensation-handler.ts`
+        // executes on failure — it MUST survive the editor round trip.
+        ...activity.compensation && { compensation: activity.compensation }
       }));
-    } else {
+    } else if (!transition.kind) {
       const sourceNode = nodes.find((n) => n.id === edge.source);
       if (sourceNode && sourceNode.type === "automated" && sourceNode.data) {
         if (sourceNode.data.activityType || sourceNode.data.activityId) {
@@ -128,15 +206,27 @@ function graphToDefinition(nodes, edges, options = {}) {
   };
 }
 function definitionToGraph(definition, options = {}) {
-  const { autoLayout = true, layoutSpacing = { vertical: 200, horizontal: 300 } } = options;
+  const { autoLayout = true, layoutSpacing = { vertical: 200, horizontal: 300 }, childContracts } = options;
   const stepMap = new Map(definition.steps.map((step) => [step.stepId, step]));
-  const positions = autoLayout ? calculateSmartLayout(definition.steps, definition.transitions, layoutSpacing) : null;
-  const nodes = definition.steps.map((step, index) => {
-    let position = positions?.get(step.stepId) || { x: 250, y: 50 + index * layoutSpacing.vertical };
-    if (!autoLayout && step._editorPosition) {
-      position = step._editorPosition;
+  const storedPositions = /* @__PURE__ */ new Map();
+  for (const step of definition.steps) {
+    const stored = step._editorPosition;
+    if (stored && typeof stored.x === "number" && typeof stored.y === "number") {
+      storedPositions.set(step.stepId, { x: stored.x, y: stored.y });
     }
-    const nodeType = mapStepTypeToNodeType(step.stepType);
+  }
+  const needsDagre = autoLayout && definition.steps.some((step) => !storedPositions.has(step.stepId));
+  const dagrePositions = needsDagre ? layoutWithDagre(definition.steps, definition.transitions, {
+    direction: "LR",
+    nodeWidth: NODE_MIN_WIDTH,
+    nodeHeight: NODE_HEIGHT
+  }) : null;
+  const nodes = definition.steps.map((step, index) => {
+    const position = storedPositions.get(step.stepId) || dagrePositions?.get(step.stepId) || { x: 250, y: 50 + index * layoutSpacing.vertical };
+    const invokeAgentActivity = step.stepType === "AUTOMATED" ? step.activities?.find(
+      (activity) => activity?.activityType === "INVOKE_AGENT"
+    ) : void 0;
+    const nodeType = invokeAgentActivity ? "invokeAgent" : mapStepTypeToNodeType(step.stepType);
     const nodeData = {
       label: step.stepName,
       description: step.description,
@@ -151,6 +241,14 @@ function definitionToGraph(definition, options = {}) {
     if (step.config) {
       nodeData.config = step.config;
     }
+    const stepMetadata = step.metadata;
+    if (stepMetadata && typeof stepMetadata === "object") {
+      nodeData.stepMetadata = stepMetadata;
+      const unmappedConfig = stepMetadata.unmappedConfig;
+      if (unmappedConfig && typeof unmappedConfig === "object") {
+        nodeData.unmappedConfig = unmappedConfig;
+      }
+    }
     if (step.stepType === "USER_TASK" && step.userTaskConfig) {
       nodeData.assignedTo = step.userTaskConfig.assignedTo;
       nodeData.assignedToRoles = step.userTaskConfig.assignedToRoles || [];
@@ -169,16 +267,41 @@ function definitionToGraph(definition, options = {}) {
       if (step.userTaskConfig.escalationRules) {
         nodeData.escalationRules = step.userTaskConfig.escalationRules;
       }
+      for (const key of USER_TASK_INSPECTOR_KEYS) {
+        const persisted = step.userTaskConfig[key];
+        if (persisted !== void 0) nodeData[key] = persisted;
+      }
     }
     if (step.stepType === "WAIT_FOR_SIGNAL" && step.signalConfig) {
       nodeData.signalConfig = step.signalConfig;
     }
+    if (step.stepType === "SUB_WORKFLOW") {
+      const subWorkflowId = step.config?.subWorkflowId;
+      const contract = subWorkflowId ? childContracts?.get(subWorkflowId) : void 0;
+      if (contract?.inputs?.length) nodeData.inputs = contract.inputs;
+      if (contract?.outputs?.length) nodeData.outputs = contract.outputs;
+      if (step.config) {
+        nodeData.subWorkflowId = step.config.subWorkflowId;
+        if (step.config.version != null) {
+          nodeData.version = step.config.version;
+        }
+      }
+    }
     if (step.stepType === "AUTOMATED" && step.activities) {
       nodeData.activities = step.activities;
     }
+    if (invokeAgentActivity) {
+      if (step.signalConfig) {
+        nodeData.signalConfig = step.signalConfig;
+      }
+      nodeData.agentId = invokeAgentActivity.config?.agentId;
+    }
     if (step.stepType === "START" && step.preConditions) {
       nodeData.preConditions = step.preConditions;
     }
+    if (step.errorDirective) {
+      nodeData.errorDirective = step.errorDirective;
+    }
     nodeData.badge = getBadgeForNodeType(nodeType);
     nodeData.status = "pending";
     return {
@@ -188,95 +311,189 @@ function definitionToGraph(definition, options = {}) {
       data: nodeData
     };
   });
+  const decisionTransitionIdsByStep = /* @__PURE__ */ new Map();
+  for (const step of definition.steps) {
+    if (step.stepType !== "USER_TASK") continue;
+    const transitionIds = (step.userTaskConfig?.decisions ?? []).map((decision) => decision.transitionId).filter(
+      (transitionId) => typeof transitionId === "string"
+    );
+    if (transitionIds.length > 0) {
+      decisionTransitionIdsByStep.set(step.stepId, new Set(transitionIds));
+    }
+  }
   const edges = definition.transitions.map((transition) => {
-    return {
+    const routeTransition = transition;
+    const routeKind = findRouteKindDescriptor(routeTransition.kind);
+    const decisionSourceHandle = decisionTransitionIdsByStep.get(transition.fromStepId)?.has(transition.transitionId) ? transition.transitionId : void 0;
+    return buildWorkflowRouteEdge({
       id: transition.transitionId,
       source: transition.fromStepId,
       target: transition.toStepId,
-      type: "workflowTransition",
+      // A kinded route re-attaches to its own output handle so the canvas
+      // renders it leaving the same port the author drew it from.
+      sourceHandle: routeKind ? routeKind.resolveSourceHandle(routeTransition) : decisionSourceHandle,
       data: {
         trigger: transition.trigger,
+        ...routeKind ? { kind: routeKind.kind } : {},
+        ...routeTransition.outcomeKind ? { outcomeKind: routeTransition.outcomeKind } : {},
         transitionName: transition.transitionName,
         priority: transition.priority !== void 0 ? transition.priority : 0,
         continueOnActivityFailure: transition.continueOnActivityFailure !== void 0 ? transition.continueOnActivityFailure : false,
         preConditions: transition.preConditions || [],
         postConditions: transition.postConditions || [],
+        condition: transition.condition,
         activities: transition.activities || [],
         label: transition.transitionName || transition.label,
         // Backward compat
         state: transition.state || "pending"
         // Default edge state
       }
-    };
+    });
   });
   return { nodes, edges };
 }
-function calculateSmartLayout(steps, transitions, spacing) {
-  const positions = /* @__PURE__ */ new Map();
-  if (steps.length === 0) return positions;
-  const outgoing = /* @__PURE__ */ new Map();
-  const incoming = /* @__PURE__ */ new Map();
-  for (const step of steps) {
-    outgoing.set(step.stepId, []);
-    incoming.set(step.stepId, []);
+function estimateNodeSize(label, hasDescription, isTerminal, outcomeRowCount = 0) {
+  const text = typeof label === "string" ? label.trim() : "";
+  const titleWidth = Math.round(text.length * 7) + 64;
+  if (isTerminal) {
+    return {
+      width: Math.min(Math.max(TERMINAL_NODE_MIN_WIDTH, titleWidth), NODE_MAX_WIDTH),
+      height: TERMINAL_NODE_HEIGHT
+    };
   }
-  for (const t of transitions) {
-    const children = outgoing.get(t.fromStepId) || [];
-    children.push(t.toStepId);
-    outgoing.set(t.fromStepId, children);
-    const parents = incoming.get(t.toStepId) || [];
-    parents.push(t.fromStepId);
-    incoming.set(t.toStepId, parents);
+  const width = hasDescription ? NODE_MAX_WIDTH : Math.min(Math.max(NODE_MIN_WIDTH, titleWidth), NODE_MAX_WIDTH);
+  const bodyHeight = hasDescription ? NODE_HEIGHT + NODE_DESCRIPTION_HEIGHT : NODE_HEIGHT;
+  const footerHeight = outcomeRowCount > 0 ? NODE_OUTCOME_FOOTER_CHROME_HEIGHT + outcomeRowCount * NODE_OUTCOME_ROW_HEIGHT : 0;
+  return { width, height: bodyHeight + footerHeight };
+}
+function isTerminalStep(step) {
+  return step.stepType === "START" || step.stepType === "END" || step.nodeType === "start" || step.nodeType === "end";
+}
+function nodeFootprint(step, outcomeRowCount = 0) {
+  if (typeof step.width === "number" && typeof step.height === "number") {
+    return { width: step.width, height: step.height };
   }
-  const startNodes = steps.filter((s) => (incoming.get(s.stepId) || []).length === 0);
-  if (startNodes.length === 0) {
-    startNodes.push(steps[0]);
+  const description = step.description;
+  const hasDescription = typeof description === "string" && description.trim().length > 0;
+  return estimateNodeSize(
+    step.stepName ?? step.label,
+    hasDescription,
+    isTerminalStep(step),
+    outcomeRowCount
+  );
+}
+function countOutcomeRows(step, transitions) {
+  const rows = countAuthoredOutcomeRows(step, transitions);
+  return rows > 0 ? rows + 1 : 0;
+}
+function countAuthoredOutcomeRows(step, transitions) {
+  const decisions = step?.userTaskConfig?.decisions ?? step?.decisions;
+  if (Array.isArray(decisions)) {
+    return decisions.filter(
+      (decision) => typeof decision === "object" && decision !== null && typeof decision.transitionId === "string"
+    ).length;
   }
-  const levels = /* @__PURE__ */ new Map();
-  const queue = [];
-  for (const start of startNodes) {
-    queue.push({ id: start.stepId, level: 0 });
+  if (!isInvokeAgentStep(step)) return 0;
+  const wired = /* @__PURE__ */ new Set();
+  for (const transition of transitions) {
+    if (transition?.fromStepId !== step.stepId) continue;
+    if (transition?.kind !== "outcome") continue;
+    if (typeof transition.outcomeKind === "string") wired.add(transition.outcomeKind);
   }
-  while (queue.length > 0) {
-    const { id, level } = queue.shift();
-    const currentLevel = levels.get(id);
-    if (currentLevel !== void 0 && level <= currentLevel) continue;
-    levels.set(id, level);
-    if (level > steps.length) continue;
-    const children = outgoing.get(id) || [];
-    for (const child of children) {
-      queue.push({ id: child, level: level + 1 });
+  wired.add("approved");
+  return wired.size;
+}
+function isInvokeAgentStep(step) {
+  if (step?.nodeType === "invokeAgent") return true;
+  const activities = step?.activities;
+  return Array.isArray(activities) && activities.some(
+    (activity) => typeof activity === "object" && activity !== null && activity.activityType === "INVOKE_AGENT"
+  );
+}
+function layoutWithDagre(steps, transitions, options = {}) {
+  const positions = /* @__PURE__ */ new Map();
+  if (steps.length === 0) return positions;
+  const rankdir = options.direction ?? "LR";
+  const graph = new dagre.graphlib.Graph();
+  graph.setDefaultEdgeLabel(() => ({}));
+  graph.setGraph({ rankdir, nodesep: 60, ranksep: 80 });
+  for (const step of steps) {
+    graph.setNode(step.stepId, nodeFootprint(step, countOutcomeRows(step, transitions)));
+  }
+  for (const transition of transitions) {
+    if (graph.hasNode(transition.fromStepId) && graph.hasNode(transition.toStepId)) {
+      graph.setEdge(transition.fromStepId, transition.toStepId, {});
     }
   }
-  const nodesByLevel = /* @__PURE__ */ new Map();
-  for (const [nodeId, level] of levels) {
-    const nodesAtLevel = nodesByLevel.get(level) || [];
-    nodesAtLevel.push(nodeId);
-    nodesByLevel.set(level, nodesAtLevel);
+  dagre.layout(graph);
+  for (const step of steps) {
+    const node = graph.node(step.stepId);
+    if (!node || typeof node.x !== "number" || typeof node.y !== "number") continue;
+    positions.set(step.stepId, {
+      x: node.x - node.width / 2,
+      y: node.y - node.height / 2
+    });
   }
-  const centerX = 400;
-  const startY = 50;
-  for (const [level, nodeIds] of nodesByLevel) {
-    const count = nodeIds.length;
-    const y = startY + level * spacing.vertical;
-    if (count === 1) {
-      positions.set(nodeIds[0], { x: centerX, y });
-    } else {
-      const totalWidth = (count - 1) * spacing.horizontal;
-      const startX = centerX - totalWidth / 2;
-      nodeIds.sort((a, b) => {
-        const parentsA = incoming.get(a) || [];
-        const parentsB = incoming.get(b) || [];
-        const parentPosA = parentsA.length > 0 ? positions.get(parentsA[0])?.x || 0 : 0;
-        const parentPosB = parentsB.length > 0 ? positions.get(parentsB[0])?.x || 0 : 0;
-        return parentPosA - parentPosB;
-      });
-      nodeIds.forEach((nodeId, idx) => {
-        positions.set(nodeId, { x: startX + idx * spacing.horizontal, y });
-      });
+  return positions;
+}
+const RETURN_LANE_GAP = 64;
+function liftReturnNodesBelow(positions, sizeById, transitions, gap = RETURN_LANE_GAP) {
+  const outDegree = /* @__PURE__ */ new Map();
+  for (const transition of transitions) {
+    outDegree.set(transition.fromStepId, (outDegree.get(transition.fromStepId) ?? 0) + 1);
+  }
+  const widthOf = (id) => sizeById.get(id)?.width ?? NODE_MIN_WIDTH;
+  const heightOf = (id) => sizeById.get(id)?.height ?? NODE_HEIGHT;
+  const result = new Map(positions);
+  for (const transition of transitions) {
+    const from = result.get(transition.fromStepId);
+    const to = result.get(transition.toStepId);
+    if (!from || !to) continue;
+    if (to.x >= from.x) continue;
+    if ((outDegree.get(transition.fromStepId) ?? 0) !== 1) continue;
+    const spanLeft = to.x;
+    const spanRight = from.x + widthOf(transition.fromStepId);
+    let laneTop = Number.NEGATIVE_INFINITY;
+    for (const [id, pos] of result) {
+      if (id === transition.fromStepId) continue;
+      const nodeRight = pos.x + widthOf(id);
+      if (nodeRight < spanLeft || pos.x > spanRight) continue;
+      laneTop = Math.max(laneTop, pos.y + heightOf(id));
     }
+    if (laneTop === Number.NEGATIVE_INFINITY) continue;
+    result.set(transition.fromStepId, { x: from.x, y: Math.round(laneTop + gap) });
   }
-  return positions;
+  return result;
+}
+function applyAutoLayout(nodes, edges) {
+  const steps = nodes.filter((node) => !isAnnotationNode(node) && !isTriggerNode(node)).map((node) => ({
+    stepId: node.id,
+    stepName: node.data?.label,
+    nodeType: node.type,
+    description: node.data?.description,
+    width: node.measured?.width,
+    height: node.measured?.height
+  }));
+  const transitions = edges.filter((edge) => !isDataMappingEdge(edge)).map((edge) => ({
+    fromStepId: edge.source,
+    toStepId: edge.target
+  }));
+  const positions = layoutWithDagre(steps, transitions, {
+    direction: "LR",
+    nodeWidth: NODE_MIN_WIDTH,
+    nodeHeight: NODE_HEIGHT
+  });
+  const sizeById = new Map(
+    steps.map((step) => [
+      step.stepId,
+      { width: step.width ?? NODE_MIN_WIDTH, height: step.height ?? NODE_HEIGHT }
+    ])
+  );
+  const laidOut = liftReturnNodesBelow(positions, sizeById, transitions);
+  return nodes.map((node) => {
+    const next = laidOut.get(node.id);
+    return next ? { ...node, position: { x: next.x, y: next.y } } : node;
+  });
 }
 function mapNodeTypeToStepType(nodeType) {
   const mapping = {
@@ -284,9 +501,17 @@ function mapNodeTypeToStepType(nodeType) {
     end: "END",
     userTask: "USER_TASK",
     automated: "AUTOMATED",
+    subWorkflow: "SUB_WORKFLOW",
     decision: "DECISION",
     waitForSignal: "WAIT_FOR_SIGNAL",
-    waitForTimer: "WAIT_FOR_TIMER"
+    waitForTimer: "WAIT_FOR_TIMER",
+    waitForCondition: "WAIT_FOR_CONDITION",
+    parallelFork: "PARALLEL_FORK",
+    parallelJoin: "PARALLEL_JOIN",
+    // The invoke-agent node is a specialization of an AUTOMATED step.
+    invokeAgent: "AUTOMATED",
+    ifElse: "IF_ELSE",
+    switch: "SWITCH"
   };
   return mapping[nodeType] || "AUTOMATED";
 }
@@ -296,9 +521,15 @@ function mapStepTypeToNodeType(stepType) {
     END: "end",
     USER_TASK: "userTask",
     AUTOMATED: "automated",
+    SUB_WORKFLOW: "subWorkflow",
     DECISION: "decision",
     WAIT_FOR_SIGNAL: "waitForSignal",
-    WAIT_FOR_TIMER: "waitForTimer"
+    WAIT_FOR_TIMER: "waitForTimer",
+    WAIT_FOR_CONDITION: "waitForCondition",
+    PARALLEL_FORK: "parallelFork",
+    PARALLEL_JOIN: "parallelJoin",
+    IF_ELSE: "ifElse",
+    SWITCH: "switch"
   };
   return mapping[stepType] || "automated";
 }
@@ -309,13 +540,21 @@ function getBadgeForNodeType(nodeType) {
     userTask: "User Task",
     automated: "Automated",
     decision: "Decision",
+    subWorkflow: "Sub-Workflow",
     waitForSignal: "Wait for Signal",
-    waitForTimer: "Wait for Timer"
+    waitForTimer: "Wait for Timer",
+    waitForCondition: "Wait for Condition",
+    parallelFork: "Parallel Fork",
+    parallelJoin: "Parallel Join",
+    invokeAgent: "Invoke Agent",
+    ifElse: "If / Else",
+    switch: "Switch"
   };
   return badges[nodeType] || "Task";
 }
-function validateWorkflowGraph(nodes, edges) {
+function validateWorkflowGraph(allNodes, edges) {
   const errors = [];
+  const nodes = allNodes.filter((node) => !isAnnotationNode(node) && !isTriggerNode(node));
   const startNodes = nodes.filter((n) => n.type === "start");
   if (startNodes.length === 0) {
     errors.push({
@@ -424,10 +663,15 @@ function generateStepId(prefix = "step") {
   const id = `${prefix}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
   return sanitizeId(id);
 }
-function generateTransitionId(fromStepId, toStepId) {
-  const id = `e_${fromStepId}_${toStepId}`;
+const DURABLE_TRANSITION_ID_PREFIX = "t_";
+const LEGACY_TRANSITION_ID_PATTERN = /^e_/;
+function generateTransitionId(_fromStepId, _toStepId) {
+  const id = `${DURABLE_TRANSITION_ID_PREFIX}${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 11)}`;
   return sanitizeId(id);
 }
+function isLegacyTransitionId(transitionId) {
+  return LEGACY_TRANSITION_ID_PATTERN.test(transitionId);
+}
 function appendWorkflowEdge(edges, edge) {
   const isDuplicate = edges.some(
     (existing) => existing.source === edge.source && existing.target === edge.target && // Match addEdge: empty-string and nullish handles are equivalent.
@@ -436,11 +680,18 @@ function appendWorkflowEdge(edges, edge) {
   return isDuplicate ? edges : [...edges, edge];
 }
 export {
+  DURABLE_TRANSITION_ID_PREFIX,
+  RETURN_LANE_GAP,
   appendWorkflowEdge,
+  applyAutoLayout,
   definitionToGraph,
   generateStepId,
   generateTransitionId,
+  getBadgeForNodeType,
   graphToDefinition,
+  isLegacyTransitionId,
+  liftReturnNodesBelow,
+  nodeFootprint,
   sanitizeId,
   validateId,
   validateWorkflowGraph