bpmn-elk-layout 1.2.0 → 1.3.0

package/dist/bin/bpmn-elk-layout.js

@@ -1251,8 +1251,6 @@ var init_bpmn_constants = __esm({
       "dataObject",
       "dataObjectReference",
       "dataStoreReference",
-      "dataInput",
-      "dataOutput",
       "textAnnotation"
     ]);
   }
@@ -2022,10 +2020,13 @@ var init_lane_arranger = __esm({
             console.log(`[BPMN]   targetPos=${JSON.stringify(targetPos)}`);
           }
           if (sourcePos && targetPos) {
-            const startX = sourcePos.x + sourcePos.width;
-            const startY = sourcePos.y + sourcePos.height / 2;
-            const endX = targetPos.x;
-            const endY = targetPos.y + targetPos.height / 2;
+            const { startX, startY, endX, endY } = this.calculateConnectionPoints(
+              sourcePos,
+              targetPos,
+              sourceId,
+              targetId,
+              nodePositions
+            );
             if (isDebugEnabled()) {
               console.log(`[BPMN]   startX=${startX}, startY=${startY}, endX=${endX}, endY=${endY}`);
             }
@@ -2040,33 +2041,10 @@ var init_lane_arranger = __esm({
               targetId,
               nodePositions
             );
-            if (Math.abs(startY - endY) > 10 || obstaclesInPath.length > 0) {
-              if (obstaclesInPath.length > 0 && Math.abs(startY - endY) <= 10) {
-                const routePoints = this.routeAroundObstacles(
-                  startX,
-                  startY,
-                  endX,
-                  endY,
-                  obstaclesInPath,
-                  nodePositions
-                );
-                for (const pt of routePoints) {
-                  waypoints.push(pt);
-                }
-              } else {
-                const midX = this.findClearMidX(
-                  startX,
-                  endX,
-                  startY,
-                  endY,
-                  sourceId,
-                  targetId,
-                  nodePositions
-                );
-                if (midX !== null) {
-                  waypoints.push({ x: midX, y: startY });
-                  waypoints.push({ x: midX, y: endY });
-                } else {
+            const isHorizontalFlow = this.isHorizontalConnection(startX, startY, endX, endY, sourcePos, targetPos);
+            if (isHorizontalFlow && Math.abs(startY - endY) > 10 || !isHorizontalFlow && Math.abs(startX - endX) > 10 || obstaclesInPath.length > 0) {
+              if (isHorizontalFlow) {
+                if (obstaclesInPath.length > 0 && Math.abs(startY - endY) <= 10) {
                   const routePoints = this.routeAroundObstacles(
                     startX,
                     startY,
@@ -2078,6 +2056,50 @@ var init_lane_arranger = __esm({
                   for (const pt of routePoints) {
                     waypoints.push(pt);
                   }
+                } else {
+                  const midX = this.findClearMidX(
+                    startX,
+                    endX,
+                    startY,
+                    endY,
+                    sourceId,
+                    targetId,
+                    nodePositions
+                  );
+                  if (midX !== null) {
+                    waypoints.push({ x: midX, y: startY });
+                    waypoints.push({ x: midX, y: endY });
+                  } else {
+                    const routePoints = this.routeAroundObstacles(
+                      startX,
+                      startY,
+                      endX,
+                      endY,
+                      obstaclesInPath,
+                      nodePositions
+                    );
+                    for (const pt of routePoints) {
+                      waypoints.push(pt);
+                    }
+                  }
+                }
+              } else {
+                const midY = this.findClearMidY(
+                  startX,
+                  endX,
+                  startY,
+                  endY,
+                  sourceId,
+                  targetId,
+                  nodePositions
+                );
+                if (midY !== null) {
+                  waypoints.push({ x: startX, y: midY });
+                  waypoints.push({ x: endX, y: midY });
+                } else {
+                  const simpleMidY = (startY + endY) / 2;
+                  waypoints.push({ x: startX, y: simpleMidY });
+                  waypoints.push({ x: endX, y: simpleMidY });
                 }
               }
             }
@@ -2095,6 +2117,265 @@ var init_lane_arranger = __esm({
           }
         }
       }
+      /**
+       * Calculate optimal connection points based on relative node positions.
+       * Chooses the best sides (left/right/top/bottom) to connect nodes to minimize edge crossings.
+       *
+       * For BPMN diagrams, we prefer horizontal connections (left-to-right flow) even for cross-lane edges,
+       * because BPMN processes typically flow horizontally.
+       */
+      calculateConnectionPoints(sourcePos, targetPos, sourceId, targetId, nodePositions) {
+        const sourceCenterX = sourcePos.x + sourcePos.width / 2;
+        const sourceCenterY = sourcePos.y + sourcePos.height / 2;
+        const targetCenterX = targetPos.x + targetPos.width / 2;
+        const targetCenterY = targetPos.y + targetPos.height / 2;
+        const dx = targetCenterX - sourceCenterX;
+        const dy = targetCenterY - sourceCenterY;
+        let startX, startY, endX, endY;
+        const horizontalDistanceSmall = Math.abs(dx) < 30;
+        const verticalDistanceSignificant = Math.abs(dy) > 50;
+        const isVerticalPrimary = horizontalDistanceSmall && verticalDistanceSignificant;
+        if (!isVerticalPrimary) {
+          startY = sourceCenterY;
+          endY = targetCenterY;
+          if (dx >= 0) {
+            startX = sourcePos.x + sourcePos.width;
+            endX = targetPos.x;
+          } else {
+            startX = sourcePos.x;
+            endX = targetPos.x + targetPos.width;
+          }
+        } else {
+          startX = sourceCenterX;
+          endX = targetCenterX;
+          if (dy >= 0) {
+            startY = sourcePos.y + sourcePos.height;
+            endY = targetPos.y;
+          } else {
+            startY = sourcePos.y;
+            endY = targetPos.y + targetPos.height;
+          }
+        }
+        const directObstacles = this.getObstaclesInPath(
+          startX,
+          startY,
+          endX,
+          endY,
+          sourceId,
+          targetId,
+          nodePositions
+        );
+        if (directObstacles.length > 0) {
+          const alternatives = this.findAlternativeConnectionPoints(
+            sourcePos,
+            targetPos,
+            dx,
+            dy,
+            !isVerticalPrimary,
+            sourceId,
+            targetId,
+            nodePositions
+          );
+          if (alternatives) {
+            return alternatives;
+          }
+        }
+        return { startX, startY, endX, endY };
+      }
+      /**
+       * Find alternative connection points that may have fewer obstacles.
+       */
+      findAlternativeConnectionPoints(sourcePos, targetPos, dx, dy, isHorizontalPrimary, sourceId, targetId, nodePositions) {
+        const sourceCenterX = sourcePos.x + sourcePos.width / 2;
+        const sourceCenterY = sourcePos.y + sourcePos.height / 2;
+        const targetCenterX = targetPos.x + targetPos.width / 2;
+        const targetCenterY = targetPos.y + targetPos.height / 2;
+        const candidates = [];
+        if (dx >= 0) {
+          candidates.push({
+            startX: sourcePos.x + sourcePos.width,
+            startY: sourceCenterY,
+            endX: targetPos.x,
+            endY: targetCenterY,
+            score: 0
+          });
+        } else {
+          candidates.push({
+            startX: sourcePos.x,
+            startY: sourceCenterY,
+            endX: targetPos.x + targetPos.width,
+            endY: targetCenterY,
+            score: 0
+          });
+        }
+        if (dy >= 0) {
+          candidates.push({
+            startX: sourceCenterX,
+            startY: sourcePos.y + sourcePos.height,
+            endX: targetCenterX,
+            endY: targetPos.y,
+            score: 0
+          });
+        } else {
+          candidates.push({
+            startX: sourceCenterX,
+            startY: sourcePos.y,
+            endX: targetCenterX,
+            endY: targetPos.y + targetPos.height,
+            score: 0
+          });
+        }
+        if (dx >= 0 && dy >= 0) {
+          candidates.push({
+            startX: sourcePos.x + sourcePos.width,
+            startY: sourceCenterY,
+            endX: targetCenterX,
+            endY: targetPos.y,
+            score: 0
+          });
+        } else if (dx >= 0 && dy < 0) {
+          candidates.push({
+            startX: sourcePos.x + sourcePos.width,
+            startY: sourceCenterY,
+            endX: targetCenterX,
+            endY: targetPos.y + targetPos.height,
+            score: 0
+          });
+        } else if (dx < 0 && dy >= 0) {
+          candidates.push({
+            startX: sourcePos.x,
+            startY: sourceCenterY,
+            endX: targetCenterX,
+            endY: targetPos.y,
+            score: 0
+          });
+        } else {
+          candidates.push({
+            startX: sourcePos.x,
+            startY: sourceCenterY,
+            endX: targetCenterX,
+            endY: targetPos.y + targetPos.height,
+            score: 0
+          });
+        }
+        for (const candidate of candidates) {
+          const obstacles = this.getObstaclesInPath(
+            candidate.startX,
+            candidate.startY,
+            candidate.endX,
+            candidate.endY,
+            sourceId,
+            targetId,
+            nodePositions
+          );
+          candidate.score = obstacles.length;
+        }
+        candidates.sort((a, b) => a.score - b.score);
+        const best = candidates[0];
+        if (best && best.score === 0) {
+          return { startX: best.startX, startY: best.startY, endX: best.endX, endY: best.endY };
+        }
+        return null;
+      }
+      /**
+       * Determine if the connection is primarily horizontal or vertical.
+       */
+      isHorizontalConnection(startX, startY, endX, endY, sourcePos, targetPos) {
+        const isStartOnHorizontalEdge = Math.abs(startX - sourcePos.x) < 1 || Math.abs(startX - (sourcePos.x + sourcePos.width)) < 1;
+        return isStartOnHorizontalEdge;
+      }
+      /**
+       * Find a clear Y position for horizontal edge segment that avoids obstacles.
+       * Similar to findClearMidX but for vertical flow routing.
+       */
+      findClearMidY(startX, endX, startY, endY, sourceId, targetId, nodePositions) {
+        const margin = 15;
+        const minX = Math.min(startX, endX);
+        const maxX = Math.max(startX, endX);
+        const rangeMinY = Math.min(startY, endY);
+        const rangeMaxY = Math.max(startY, endY);
+        const flowNodePatterns = [
+          /^task_/,
+          /^gateway_/,
+          /^start_/,
+          /^end_/,
+          /^subprocess_/,
+          /^call_/,
+          /^intermediate_/,
+          /^event_/,
+          /^catch_/
+        ];
+        const allObstacles = [];
+        for (const [nodeId, pos] of nodePositions) {
+          if (nodeId === sourceId || nodeId === targetId) continue;
+          if (nodeId.startsWith("lane_")) continue;
+          const isFlowNode = flowNodePatterns.some((pattern) => pattern.test(nodeId));
+          if (!isFlowNode) continue;
+          const nodeLeft = pos.x;
+          const nodeRight = pos.x + pos.width;
+          const nodeTop = pos.y;
+          const nodeBottom = pos.y + pos.height;
+          const yOverlap = nodeBottom > rangeMinY && nodeTop < rangeMaxY;
+          const xOverlapHorizontal = nodeRight > minX && nodeLeft < maxX;
+          const xContainsStartX = nodeLeft <= startX && nodeRight >= startX;
+          const xContainsEndX = nodeLeft <= endX && nodeRight >= endX;
+          if (yOverlap && (xOverlapHorizontal || xContainsStartX || xContainsEndX)) {
+            allObstacles.push({
+              x: nodeLeft,
+              y: nodeTop,
+              width: pos.width,
+              height: pos.height,
+              right: nodeRight,
+              bottom: nodeBottom
+            });
+          }
+        }
+        if (allObstacles.length === 0) {
+          return (startY + endY) / 2;
+        }
+        const isValidMidY = (midY) => {
+          for (const obs of allObstacles) {
+            const seg1MinY = Math.min(startY, midY);
+            const seg1MaxY = Math.max(startY, midY);
+            if (obs.x <= startX && obs.right >= startX && obs.bottom > seg1MinY && obs.y < seg1MaxY) {
+              return false;
+            }
+            if (obs.y <= midY && obs.bottom >= midY && obs.right > minX && obs.x < maxX) {
+              return false;
+            }
+            const seg2MinY = Math.min(midY, endY);
+            const seg2MaxY = Math.max(midY, endY);
+            if (obs.x <= endX && obs.right >= endX && obs.bottom > seg2MinY && obs.y < seg2MaxY) {
+              return false;
+            }
+          }
+          return true;
+        };
+        const candidates = [];
+        candidates.push((startY + endY) / 2);
+        candidates.push(startY + margin);
+        candidates.push(endY - margin);
+        for (const obs of allObstacles) {
+          candidates.push(obs.y - margin);
+          candidates.push(obs.bottom + margin);
+        }
+        const simpleMidY = (startY + endY) / 2;
+        const validCandidates = candidates.filter((y) => y >= rangeMinY && y <= rangeMaxY).sort((a, b) => Math.abs(a - simpleMidY) - Math.abs(b - simpleMidY));
+        for (const candidate of validCandidates) {
+          if (isValidMidY(candidate)) {
+            return candidate;
+          }
+        }
+        const topMost = Math.min(...allObstacles.map((o) => o.y)) - margin;
+        const bottomMost = Math.max(...allObstacles.map((o) => o.bottom)) + margin;
+        if (topMost >= rangeMinY && isValidMidY(topMost)) {
+          return topMost;
+        }
+        if (bottomMost <= rangeMaxY && isValidMidY(bottomMost)) {
+          return bottomMost;
+        }
+        return null;
+      }
       /**
        * Get obstacles in the direct path from source to target.
        * This handles the case where source and target are at similar Y positions
@@ -3980,6 +4261,23 @@ var init_elk_graph_preparer = __esm({
             "elk.layered.layering.layerConstraint": "LAST"
           };
         }
+        const ioSpec = node.bpmn?.ioSpecification;
+        let ioSpecExtraHeight = 0;
+        if (ioSpec) {
+          const dataInputs = ioSpec.dataInputs ?? [];
+          const dataOutputs = ioSpec.dataOutputs ?? [];
+          const maxCount = Math.max(dataInputs.length, dataOutputs.length);
+          if (maxCount > 0) {
+            const dataHeight = 50;
+            const gapBelow = 20;
+            const verticalSpacing = 24;
+            const labelHeight = 14;
+            ioSpecExtraHeight = gapBelow + maxCount * (dataHeight + verticalSpacing) + labelHeight;
+            if (isDebugEnabled()) {
+              console.log(`[BPMN] Adding extra height ${ioSpecExtraHeight} for node ${node.id} with ioSpecification`);
+            }
+          }
+        }
         if (mainFlowNodes.has(node.id) && !boundaryEventTargetIds.has(node.id)) {
           layoutOptions = {
             ...layoutOptions,
@@ -4059,12 +4357,15 @@ var init_elk_graph_preparer = __esm({
             "elk.padding": "[top=12,left=12,bottom=12,right=12]"
           };
         }
+        const originalHeight = node.height ?? 80;
+        const elkHeight = originalHeight + ioSpecExtraHeight;
+        const bpmnWithVisualHeight = ioSpecExtraHeight > 0 ? { ...node.bpmn, _visualHeight: originalHeight } : node.bpmn;
         const elkNode = {
           id: node.id,
           width: node.width,
-          height: node.height,
+          height: elkHeight,
           layoutOptions,
-          bpmn: node.bpmn
+          bpmn: bpmnWithVisualHeight
         };
         if (node.children && node.children.length > 0) {
           const childNodes = [];
@@ -4231,12 +4532,16 @@ var init_result_merger = __esm({
        * Merge a single node's layout results with original BPMN data
        */
       mergeNodeResults(original, layouted) {
+        const layoutedBpmn = layouted.bpmn;
+        const visualHeight = layoutedBpmn?._visualHeight;
+        const mergedBpmn = visualHeight !== void 0 ? { ...original.bpmn, _visualHeight: visualHeight } : original.bpmn;
         const result = {
           ...original,
           x: layouted.x ?? 0,
           y: layouted.y ?? 0,
           width: layouted.width ?? original.width,
-          height: layouted.height ?? original.height
+          height: layouted.height ?? original.height,
+          bpmn: mergedBpmn
         };
         if (original.children && layouted.children) {
           const layoutedChildMap = new Map(layouted.children.map((c) => [c.id, c]));
@@ -4898,23 +5203,36 @@ var init_diagram_builder = __esm({
           const absoluteX = offsetX + node.x;
           const absoluteY = offsetY + node.y;
           const nodeWidth = node.width ?? 100;
-          const nodeHeight = node.height ?? 80;
+          const bpmnAny = node.bpmn;
+          const nodeHeight = bpmnAny?._visualHeight ?? node.height ?? 80;
           let effectiveHeight = nodeHeight;
           if (this.isEventType(node.bpmn?.type) && node.labels && node.labels.length > 0) {
             const labelHeight = node.labels[0]?.height ?? 14;
             effectiveHeight = nodeHeight + 4 + labelHeight;
           }
-          this.nodePositions.set(node.id, {
+          const nodePosition = {
             x: absoluteX,
             y: absoluteY,
             width: nodeWidth,
             height: effectiveHeight
-          });
+          };
+          if (bpmnAny?._visualHeight !== void 0) {
+            nodePosition.visualHeight = bpmnAny._visualHeight;
+          }
+          this.nodePositions.set(node.id, nodePosition);
           if (node.bpmn) {
             this.storeNodeBpmn(node.id, { type: node.bpmn.type });
           }
           this.nodeOffsets.set(node.id, { x: offsetX, y: offsetY });
           shapes.push(this.buildShape(node, offsetX, offsetY));
+          const nodeType = node.bpmn?.type;
+          const isTaskOrActivity = nodeType && (nodeType.includes("Task") || nodeType === "task" || nodeType === "callActivity" || nodeType === "subProcess" || nodeType === "transaction" || nodeType === "adHocSubProcess");
+          if (isTaskOrActivity) {
+            const ioSpec = node.bpmn?.ioSpecification;
+            if (ioSpec) {
+              this.buildIoSpecificationShapes(node, ioSpec, shapes, edges, absoluteX, absoluteY, nodeWidth, nodeHeight);
+            }
+          }
         }
         const isExpandedSubprocess = node.bpmn?.isExpanded === true && (node.bpmn?.type === "subProcess" || node.bpmn?.type === "transaction" || node.bpmn?.type === "adHocSubProcess" || node.bpmn?.type === "eventSubProcess" || node.bpmn?.triggeredByEvent === true);
         const isPoolOrLane = node.bpmn?.type === "participant" || node.bpmn?.type === "lane";
@@ -4998,6 +5316,131 @@ var init_diagram_builder = __esm({
       storeNodeBpmn(nodeId, bpmn) {
         this.nodeBpmn.set(nodeId, bpmn);
       }
+      /**
+       * Build shapes for ioSpecification dataInputs and dataOutputs
+       * Positions: dataInputs below-left of the task (stacked vertically),
+       *            dataOutputs below-right of the task (stacked vertically)
+       * Only the topmost item in each stack has a dashed association edge to the task
+       */
+      buildIoSpecificationShapes(node, ioSpec, shapes, edges, taskX, taskY, taskWidth, taskHeight) {
+        const dataWidth = 36;
+        const dataHeight = 50;
+        const gapBelow = 20;
+        const verticalSpacing = 24;
+        const labelHeight = 14;
+        const dataInputs = ioSpec.dataInputs ?? [];
+        const inputStartX = taskX;
+        dataInputs.forEach((dataInput, index) => {
+          const inputId = dataInput.id ?? `${node.id}_input_${index}`;
+          const inputX = inputStartX;
+          const inputY = taskY + taskHeight + gapBelow + index * (dataHeight + verticalSpacing);
+          this.nodePositions.set(inputId, {
+            x: inputX,
+            y: inputY,
+            width: dataWidth,
+            height: dataHeight
+          });
+          const shape = {
+            id: `${inputId}_di`,
+            bpmnElement: inputId,
+            bounds: {
+              x: inputX,
+              y: inputY,
+              width: dataWidth,
+              height: dataHeight
+            }
+          };
+          if (dataInput.name) {
+            const labelWidth = Math.max(dataWidth, this.estimateTextWidth(dataInput.name));
+            shape.label = {
+              bounds: {
+                x: inputX + (dataWidth - labelWidth) / 2,
+                y: inputY + dataHeight + 4,
+                width: labelWidth,
+                height: labelHeight
+              }
+            };
+          }
+          shapes.push(shape);
+          if (index === 0) {
+            const assocId = `${inputId}_assoc`;
+            const inputCenterX = inputX + dataWidth / 2;
+            const inputTopY = inputY;
+            const taskBottomY = taskY + taskHeight;
+            edges.push({
+              id: `${assocId}_di`,
+              bpmnElement: assocId,
+              waypoints: [
+                { x: inputCenterX, y: inputTopY },
+                { x: inputCenterX, y: taskBottomY }
+              ]
+            });
+          }
+        });
+        const dataOutputs = ioSpec.dataOutputs ?? [];
+        const outputStartX = taskX + taskWidth - dataWidth;
+        dataOutputs.forEach((dataOutput, index) => {
+          const outputId = dataOutput.id ?? `${node.id}_output_${index}`;
+          const outputX = outputStartX;
+          const outputY = taskY + taskHeight + gapBelow + index * (dataHeight + verticalSpacing);
+          this.nodePositions.set(outputId, {
+            x: outputX,
+            y: outputY,
+            width: dataWidth,
+            height: dataHeight
+          });
+          const shape = {
+            id: `${outputId}_di`,
+            bpmnElement: outputId,
+            bounds: {
+              x: outputX,
+              y: outputY,
+              width: dataWidth,
+              height: dataHeight
+            }
+          };
+          if (dataOutput.name) {
+            const labelWidth = Math.max(dataWidth, this.estimateTextWidth(dataOutput.name));
+            shape.label = {
+              bounds: {
+                x: outputX + (dataWidth - labelWidth) / 2,
+                y: outputY + dataHeight + 4,
+                width: labelWidth,
+                height: labelHeight
+              }
+            };
+          }
+          shapes.push(shape);
+          if (index === 0) {
+            const assocId = `${outputId}_assoc`;
+            const outputCenterX = outputX + dataWidth / 2;
+            const outputTopY = outputY;
+            const taskBottomY = taskY + taskHeight;
+            edges.push({
+              id: `${assocId}_di`,
+              bpmnElement: assocId,
+              waypoints: [
+                { x: outputCenterX, y: taskBottomY },
+                { x: outputCenterX, y: outputTopY }
+              ]
+            });
+          }
+        });
+      }
+      /**
+       * Estimate text width for label sizing (simplified)
+       */
+      estimateTextWidth(text) {
+        let width = 0;
+        for (const char of text) {
+          if (char.charCodeAt(0) > 255) {
+            width += 14;
+          } else {
+            width += 7;
+          }
+        }
+        return Math.max(36, Math.min(width, 150));
+      }
       /**
        * Find node BPMN metadata by id
        */
@@ -5029,6 +5472,8 @@ var init_diagram_builder = __esm({
       buildShape(node, offsetX = 0, offsetY = 0) {
         const absoluteX = offsetX + (node.x ?? 0);
         const absoluteY = offsetY + (node.y ?? 0);
+        const bpmnAny = node.bpmn;
+        const visualHeight = bpmnAny?._visualHeight ?? node.height ?? 80;
         const shape = {
           id: `${node.id}_di`,
           bpmnElement: node.id,
@@ -5036,7 +5481,7 @@ var init_diagram_builder = __esm({
             x: absoluteX,
             y: absoluteY,
             width: node.width ?? 100,
-            height: node.height ?? 80
+            height: visualHeight
           }
         };
         if (node.bpmn?.isExpanded !== void 0) {
@@ -5046,7 +5491,7 @@ var init_diagram_builder = __esm({
           shape.isHorizontal = true;
         }
         const nodeWidth = node.width ?? 36;
-        const nodeHeight = node.height ?? 36;
+        const nodeHeight = bpmnAny?._visualHeight ?? node.height ?? 36;
         const label = node.labels?.[0];
         const labelText = node.bpmn?.name ?? label?.text ?? "";
         if (this.isEventType(node.bpmn?.type) && labelText) {
@@ -5174,6 +5619,7 @@ var init_diagram_builder = __esm({
               }
             }
           }
+          this.adjustEndpointsForVisualHeight(waypoints, sourceId, targetId);
         }
         this.ensureOrthogonalWaypoints(waypoints);
         this.ensurePerpendicularEndpoints(
@@ -5216,6 +5662,66 @@ var init_diagram_builder = __esm({
         }
         return edgeModel;
       }
+      /**
+       * Adjust edge endpoints for nodes with ioSpecification (visualHeight)
+       *
+       * When a node has ioSpecification, ELK uses an enlarged height for layout (to make space for data objects).
+       * However, the edge endpoints should connect to the visual node border, not based on the layout height.
+       *
+       * This method adjusts endpoint Y coordinates and also adjusts adjacent waypoints if they were
+       * on the same horizontal line, to maintain horizontal segments without introducing extra bends.
+       */
+      adjustEndpointsForVisualHeight(waypoints, sourceId, targetId) {
+        if (waypoints.length < 2) return;
+        const tolerance = 5;
+        if (sourceId) {
+          const sourcePos = this.nodePositions.get(sourceId);
+          if (sourcePos?.visualHeight !== void 0) {
+            const firstWp = waypoints[0];
+            const secondWp = waypoints[1];
+            if (firstWp && secondWp) {
+              const nodeRight = sourcePos.x + sourcePos.width;
+              const nodeLeft = sourcePos.x;
+              const visualBottom = sourcePos.y + sourcePos.visualHeight;
+              const visualCenterY = sourcePos.y + sourcePos.visualHeight / 2;
+              if (Math.abs(firstWp.x - nodeRight) < tolerance || Math.abs(firstWp.x - nodeLeft) < tolerance) {
+                const oldY = firstWp.y;
+                const newY = visualCenterY;
+                firstWp.y = newY;
+                if (Math.abs(secondWp.y - oldY) < tolerance && waypoints.length > 2) {
+                  secondWp.y = newY;
+                }
+              } else if (firstWp.y > visualBottom) {
+                firstWp.y = visualBottom;
+              }
+            }
+          }
+        }
+        if (targetId) {
+          const targetPos = this.nodePositions.get(targetId);
+          if (targetPos?.visualHeight !== void 0) {
+            const lastIdx = waypoints.length - 1;
+            const lastWp = waypoints[lastIdx];
+            const prevWp = waypoints[lastIdx - 1];
+            if (lastWp && prevWp) {
+              const nodeLeft = targetPos.x;
+              const nodeRight = targetPos.x + targetPos.width;
+              const visualBottom = targetPos.y + targetPos.visualHeight;
+              const visualCenterY = targetPos.y + targetPos.visualHeight / 2;
+              if (Math.abs(lastWp.x - nodeLeft) < tolerance || Math.abs(lastWp.x - nodeRight) < tolerance) {
+                const oldY = lastWp.y;
+                const newY = visualCenterY;
+                lastWp.y = newY;
+                if (Math.abs(prevWp.y - oldY) < tolerance && waypoints.length > 2) {
+                  prevWp.y = newY;
+                }
+              } else if (lastWp.y > visualBottom) {
+                lastWp.y = visualBottom;
+              }
+            }
+          }
+        }
+      }
       /**
        * Calculate smart label position on the edge
        * Strategy:
@@ -5696,7 +6202,7 @@ var init_model_builder = __esm({
       buildFlowElement(node) {
         const incoming = this.refResolver.getIncomingSequenceFlows(node.id);
         const outgoing = this.refResolver.getOutgoingSequenceFlows(node.id);
-        return {
+        const flowElement = {
           type: node.bpmn?.type ?? "task",
           id: node.id,
           name: node.bpmn?.name,
@@ -5704,6 +6210,76 @@ var init_model_builder = __esm({
           outgoing,
           properties: this.extractProperties(node.bpmn ?? {})
         };
+        const ioSpec = node.bpmn?.ioSpecification;
+        if (ioSpec) {
+          flowElement.ioSpecification = this.buildIoSpecification(ioSpec, node.id);
+          const dataInputs = ioSpec.dataInputs ?? [];
+          if (dataInputs.length > 0) {
+            const firstInput = dataInputs[0];
+            flowElement.dataInputAssociations = [{
+              id: `${firstInput.id ?? `${node.id}_input_0`}_assoc`,
+              sourceRef: firstInput.id ?? `${node.id}_input_0`,
+              targetRef: node.id
+            }];
+          }
+          const dataOutputs = ioSpec.dataOutputs ?? [];
+          if (dataOutputs.length > 0) {
+            const firstOutput = dataOutputs[0];
+            flowElement.dataOutputAssociations = [{
+              id: `${firstOutput.id ?? `${node.id}_output_0`}_assoc`,
+              sourceRef: node.id,
+              targetRef: firstOutput.id ?? `${node.id}_output_0`
+            }];
+          }
+        }
+        return flowElement;
+      }
+      /**
+       * Build ioSpecification model from input
+       */
+      buildIoSpecification(ioSpec, taskId) {
+        const dataInputs = (ioSpec.dataInputs ?? []).map((di, index) => ({
+          id: di.id ?? `${taskId}_input_${index}`,
+          name: di.name,
+          itemSubjectRef: di.itemSubjectRef,
+          isCollection: di.isCollection
+        }));
+        const dataOutputs = (ioSpec.dataOutputs ?? []).map((dout, index) => ({
+          id: dout.id ?? `${taskId}_output_${index}`,
+          name: dout.name,
+          itemSubjectRef: dout.itemSubjectRef,
+          isCollection: dout.isCollection
+        }));
+        const inputSets = (ioSpec.inputSets ?? []).map((is, index) => ({
+          id: is.id ?? `${taskId}_inputSet_${index}`,
+          name: is.name,
+          dataInputRefs: is.dataInputRefs ?? []
+        }));
+        if (inputSets.length === 0 && dataInputs.length > 0) {
+          inputSets.push({
+            id: `${taskId}_inputSet_0`,
+            name: void 0,
+            dataInputRefs: dataInputs.map((di) => di.id)
+          });
+        }
+        const outputSets = (ioSpec.outputSets ?? []).map((os, index) => ({
+          id: os.id ?? `${taskId}_outputSet_${index}`,
+          name: os.name,
+          dataOutputRefs: os.dataOutputRefs ?? []
+        }));
+        if (outputSets.length === 0 && dataOutputs.length > 0) {
+          outputSets.push({
+            id: `${taskId}_outputSet_0`,
+            name: void 0,
+            dataOutputRefs: dataOutputs.map((dout) => dout.id)
+          });
+        }
+        return {
+          dataInputs,
+          dataOutputs,
+          inputSets,
+          outputSets
+        };
       }
       /**
        * Build a boundary event model
@@ -6037,6 +6613,9 @@ var init_bpmn_xml_generator = __esm({
         }
         if (element.type.includes("Task") || element.type === "task") {
           this.applyTaskProperties(bpmnElement, props);
+          if (element.ioSpecification) {
+            bpmnElement.ioSpecification = this.buildIoSpecification(element.ioSpecification);
+          }
         }
         if (element.type.includes("Gateway")) {
           this.applyGatewayProperties(bpmnElement, props);
@@ -6229,6 +6808,55 @@ var init_bpmn_xml_generator = __esm({
           });
         }
       }
+      /**
+       * Build ioSpecification element
+       */
+      buildIoSpecification(ioSpec) {
+        const ioSpecElement = this.moddle.create("bpmn:InputOutputSpecification", {});
+        if (ioSpec.dataInputs.length > 0) {
+          ioSpecElement.dataInputs = ioSpec.dataInputs.map((di) => {
+            return this.moddle.create("bpmn:DataInput", {
+              id: di.id,
+              name: di.name,
+              isCollection: di.isCollection
+            });
+          });
+        }
+        if (ioSpec.dataOutputs.length > 0) {
+          ioSpecElement.dataOutputs = ioSpec.dataOutputs.map((dout) => {
+            return this.moddle.create("bpmn:DataOutput", {
+              id: dout.id,
+              name: dout.name,
+              isCollection: dout.isCollection
+            });
+          });
+        }
+        if (ioSpec.inputSets.length > 0) {
+          ioSpecElement.inputSets = ioSpec.inputSets.map((is) => {
+            const inputSet = this.moddle.create("bpmn:InputSet", {
+              id: is.id,
+              name: is.name
+            });
+            if (is.dataInputRefs.length > 0) {
+              inputSet.dataInputRefs = is.dataInputRefs.map((ref) => ({ id: ref }));
+            }
+            return inputSet;
+          });
+        }
+        if (ioSpec.outputSets.length > 0) {
+          ioSpecElement.outputSets = ioSpec.outputSets.map((os) => {
+            const outputSet = this.moddle.create("bpmn:OutputSet", {
+              id: os.id,
+              name: os.name
+            });
+            if (os.dataOutputRefs.length > 0) {
+              outputSet.dataOutputRefs = os.dataOutputRefs.map((ref) => ({ id: ref }));
+            }
+            return outputSet;
+          });
+        }
+        return ioSpecElement;
+      }
       /**
        * Apply data associations (BPMN 2.0 spec: dataInputAssociation/dataOutputAssociation are child elements of Activity)
        */