@aranzatech/diagrams-bpmn 0.3.1 → 0.3.3

package/dist/layout/index.d.cts

@@ -1,13 +1,13 @@
 import { LayoutResult, LayoutOptions } from '@aranzatech/diagrams-core/types';
 export { applyLayoutResultToDiagram } from '@aranzatech/diagrams-core/layout';
-import { d as BpmnRFNode, c as BpmnRFEdge } from '../types-CggktCqr.cjs';
+import { d as BpmnRFNode, c as BpmnRFEdge } from '../types-CDp9kWQ4.cjs';
 import { BpmnDiagramState } from '../modeling/index.cjs';
 import '@xyflow/react';
-import '../types-BYN4Zuee.cjs';
-import '../types-BX_o95GC.cjs';
+import '../types-nvF59RGF.cjs';
+import '../types-dQUuSnV5.cjs';
 import '@aranzatech/diagrams-core';
 import '@aranzatech/diagrams-core/serialization';
-import '../catalog-DAGDhO-D.cjs';
+import '../catalog-DG-sz0VM.cjs';
 
 /**
  * ELK-based auto-layout for BPMN diagrams.

package/dist/layout/index.d.ts

@@ -1,13 +1,13 @@
 import { LayoutResult, LayoutOptions } from '@aranzatech/diagrams-core/types';
 export { applyLayoutResultToDiagram } from '@aranzatech/diagrams-core/layout';
-import { d as BpmnRFNode, c as BpmnRFEdge } from '../types-DmDODKlh.js';
+import { d as BpmnRFNode, c as BpmnRFEdge } from '../types-CuDL2YGL.js';
 import { BpmnDiagramState } from '../modeling/index.js';
 import '@xyflow/react';
-import '../types-BYN4Zuee.js';
-import '../types-D7zel9dq.js';
+import '../types-nvF59RGF.js';
+import '../types-X5FyP8oS.js';
 import '@aranzatech/diagrams-core';
 import '@aranzatech/diagrams-core/serialization';
-import '../catalog-Q1QmKLDD.js';
+import '../catalog-DNIyjHbl.js';
 
 /**
  * ELK-based auto-layout for BPMN diagrams.

package/dist/layout/index.js

@@ -135,6 +135,17 @@ function detectGatewayPairs(nodes, forwardEdges) {
   }
   return pairs;
 }
+function createSecondaryOffsets(count) {
+  if (count <= 0) return [];
+  const offsets = [];
+  let step = 1;
+  while (offsets.length < count) {
+    offsets.push(-step);
+    if (offsets.length < count) offsets.push(step);
+    step++;
+  }
+  return offsets;
+}
 function handleToRowBias(handle) {
   if (!handle) return null;
   if (handle.includes("top")) return -1;
@@ -150,6 +161,52 @@ function buildHandleMap(edges) {
   }
   return map;
 }
+function pickMainBranch(branchData) {
+  if (branchData.length === 0) return void 0;
+  return [...branchData].sort((a, b) => {
+    const aRight = a.bias === 0 ? 1 : 0;
+    const bRight = b.bias === 0 ? 1 : 0;
+    if (aRight !== bRight) return bRight - aRight;
+    if (a.nodeIds.length !== b.nodeIds.length) return b.nodeIds.length - a.nodeIds.length;
+    return a.start.localeCompare(b.start);
+  })[0]?.start;
+}
+function resolveDirectionalRow(splitRow, preferredOffset, usedRows) {
+  if (preferredOffset === 0 && !usedRows.has(splitRow)) return splitRow;
+  const direction = preferredOffset < 0 ? -1 : 1;
+  let distance = Math.max(1, Math.abs(preferredOffset));
+  while (usedRows.has(splitRow + direction * distance)) distance++;
+  return splitRow + direction * distance;
+}
+function assignBranchRowsAroundMain(branchData, splitRow) {
+  const assigned = /* @__PURE__ */ new Map();
+  const mainBranchStart = pickMainBranch(branchData);
+  if (mainBranchStart) assigned.set(mainBranchStart, splitRow);
+  const usedRows = new Set(assigned.values());
+  const remaining = branchData.filter((branch) => branch.start !== mainBranchStart);
+  const withBias = remaining.filter((branch) => branch.bias !== null && branch.bias !== 0).sort((a, b) => {
+    const aMag = Math.abs(a.bias ?? 0);
+    const bMag = Math.abs(b.bias ?? 0);
+    if (aMag !== bMag) return aMag - bMag;
+    return a.start.localeCompare(b.start);
+  });
+  const withoutBias = remaining.filter((branch) => branch.bias === null || branch.bias === 0).sort((a, b) => b.nodeIds.length - a.nodeIds.length || a.start.localeCompare(b.start));
+  for (const branch of withBias) {
+    const row = resolveDirectionalRow(splitRow, branch.bias ?? 0, usedRows);
+    assigned.set(branch.start, row);
+    usedRows.add(row);
+  }
+  const preferredOffsets = createSecondaryOffsets(withoutBias.length);
+  for (let i = 0; i < withoutBias.length; i++) {
+    let row = splitRow + preferredOffsets[i];
+    if (usedRows.has(row)) {
+      row = resolveDirectionalRow(splitRow, preferredOffsets[i], usedRows);
+    }
+    assigned.set(withoutBias[i].start, row);
+    usedRows.add(row);
+  }
+  return assigned;
+}
 function assignRows(nodes, forwardEdges, columns, gatewayPairs) {
   const rows = new Map(nodes.map((n) => [n.id, 0]));
   const succs = new Map(nodes.map((n) => [n.id, []]));
@@ -183,24 +240,14 @@ function assignRows(nodes, forwardEdges, columns, gatewayPairs) {
       nodeIds: getBranchNodes(start),
       bias: handleToRowBias(splitHandles?.get(start) ?? null)
     }));
-    const withBias = branchData.filter((b) => b.bias !== null && b.bias !== 0);
-    const withoutBias = branchData.filter((b) => b.bias === null || b.bias === 0).sort((a, b) => b.nodeIds.length - a.nodeIds.length);
-    const assigned = /* @__PURE__ */ new Map();
-    for (const b of withBias) {
-      assigned.set(b.start, splitRow + b.bias);
-    }
-    let nextOffset = 0;
-    for (const b of withoutBias) {
-      while ([...assigned.values()].includes(splitRow + nextOffset)) nextOffset++;
-      assigned.set(b.start, splitRow + nextOffset);
-      nextOffset++;
-    }
+    const assigned = assignBranchRowsAroundMain(branchData, splitRow);
     for (const b of branchData) {
       const row = assigned.get(b.start) ?? splitRow;
       for (const id of b.nodeIds) {
         rows.set(id, row);
       }
     }
+    rows.set(mergeId, splitRow);
   }
   const pairedSplits = new Set(gatewayPairs.keys());
   const unpairedSplits = nodes.filter(
@@ -229,16 +276,7 @@ function assignRows(nodes, forwardEdges, columns, gatewayPairs) {
       nodeIds: getAllReachable(start),
       bias: handleToRowBias(splitHandles2?.get(start) ?? null)
     }));
-    const withBias2 = branchData.filter((b) => b.bias !== null && b.bias !== 0);
-    const withoutBias2 = branchData.filter((b) => b.bias === null || b.bias === 0).sort((a, b) => b.nodeIds.length - a.nodeIds.length);
-    const assigned2 = /* @__PURE__ */ new Map();
-    for (const b of withBias2) assigned2.set(b.start, splitRow + b.bias);
-    let nextOff = 0;
-    for (const b of withoutBias2) {
-      while ([...assigned2.values()].includes(splitRow + nextOff)) nextOff++;
-      assigned2.set(b.start, splitRow + nextOff);
-      nextOff++;
-    }
+    const assigned2 = assignBranchRowsAroundMain(branchData, splitRow);
     for (const b of branchData) {
       const row = assigned2.get(b.start) ?? splitRow;
       for (const id of b.nodeIds) rows.set(id, row);
@@ -249,17 +287,18 @@ function assignRows(nodes, forwardEdges, columns, gatewayPairs) {
 
 // src/layout/bpmn-custom-layout.ts
 var LANE_LABEL_W = 28;
-var LANE_H_PAD = 40;
-var COL_GAP = 100;
-var ROW_HEIGHT = 100;
-var ROW_GAP = 80;
-var LANE_V_PAD = 60;
-var POOL_H_PAD = 80;
-var POOL_V_GAP = 60;
-var LANE_MIN_H = 200;
-var POOL_MIN_W = 840;
+var LANE_H_PAD = 32;
+var COL_GAP = 60;
+var ROW_HEIGHT = 90;
+var ROW_GAP = 50;
+var LANE_V_PAD = 48;
+var POOL_H_PAD = 64;
+var POOL_V_GAP = 48;
+var LANE_MIN_H = 180;
+var POOL_MIN_W = 720;
 var POOL_INNER_PAD = 10;
-var BACK_EDGE_CLEARANCE = 70;
+var BACK_EDGE_CLEARANCE = 56;
+var EDGE_ROUTE_PAD = 28;
 var LAYOUT_ARTIFACT_TYPES = /* @__PURE__ */ new Set([
   "DataObject",
   "DataObjectReference",
@@ -276,12 +315,38 @@ var COLLAPSED_SUBPROCESS_TYPES = /* @__PURE__ */ new Set([
   "EventSubProcess",
   "AdHocSubProcess"
 ]);
+var LAYOUT_TASK_TYPES = /* @__PURE__ */ new Set([
+  "Task",
+  "UserTask",
+  "ServiceTask",
+  "ScriptTask",
+  "ManualTask",
+  "BusinessRuleTask",
+  "ReceiveTask",
+  "SendTask",
+  "CallActivity"
+]);
+var TASK_LAYOUT_MIN_W = 130;
+var TASK_LAYOUT_MIN_H = 80;
 function nW(node) {
   return node.width ?? node.measured?.width ?? 120;
 }
 function nH(node) {
   return node.height ?? node.measured?.height ?? 60;
 }
+function layoutW(node) {
+  return LAYOUT_TASK_TYPES.has(node.data.elementType) ? Math.max(nW(node), TASK_LAYOUT_MIN_W) : nW(node);
+}
+function layoutH(node) {
+  return LAYOUT_TASK_TYPES.has(node.data.elementType) ? Math.max(nH(node), TASK_LAYOUT_MIN_H) : nH(node);
+}
+function applyLayoutMinSize(node) {
+  if (!LAYOUT_TASK_TYPES.has(node.data.elementType)) return node;
+  const w = layoutW(node);
+  const h = layoutH(node);
+  if (w === nW(node) && h === nH(node)) return node;
+  return { ...node, width: w, height: h, measured: { width: w, height: h } };
+}
 var BOUNDARY_SPACING = 10;
 function repositionBoundaryEvents(boundaryEvents, positionedContent) {
   if (boundaryEvents.length === 0) return [];
@@ -307,8 +372,8 @@ function repositionBoundaryEvents(boundaryEvents, positionedContent) {
     }
     const hostGroup = byHost.get(hostId);
     const siblingIdx = hostGroup.findIndex((n) => n.id === be.id);
-    const hostW = nW(host);
-    const hostH = nH(host);
+    const hostW = layoutW(host);
+    const hostH = layoutH(host);
     const beH = nH(be);
     const totalGroupW = hostGroup.reduce((s, b) => s + nW(b), 0) + (hostGroup.length - 1) * BOUNDARY_SPACING;
     const groupStartX = host.position.x + hostW / 2 - totalGroupW / 2;
@@ -349,7 +414,7 @@ function layoutSubProcess(children, edges) {
   for (let c = 0; c <= maxCol; c++) colW.set(c, 0);
   for (const node of mainChildren) {
     const c = columns.get(node.id) ?? 0;
-    colW.set(c, Math.max(colW.get(c) ?? 0, nW(node)));
+    colW.set(c, Math.max(colW.get(c) ?? 0, layoutW(node)));
   }
   const colX = /* @__PURE__ */ new Map();
   let cumX = 0;
@@ -368,12 +433,11 @@ function layoutSubProcess(children, edges) {
   const positionedChildren = mainChildren.map((node) => {
     const c = columns.get(node.id) ?? 0;
     const r = rows.get(node.id) ?? 0;
-    const colOffset = (colX.get(c) ?? 0) + (colW.get(c) ?? 120) / 2 - nW(node) / 2;
-    const rowOffset = (r - minRow) * (ROW_HEIGHT + ROW_GAP) + ROW_HEIGHT / 2 - nH(node) / 2;
-    return {
-      ...node,
-      position: { x: SP_PAD + colOffset, y: SP_PAD + rowOffset }
-    };
+    const lw = layoutW(node);
+    const lh = layoutH(node);
+    const colOffset = (colX.get(c) ?? 0) + (colW.get(c) ?? 120) / 2 - lw / 2;
+    const rowOffset = (r - minRow) * (ROW_HEIGHT + ROW_GAP) + ROW_HEIGHT / 2 - lh / 2;
+    return applyLayoutMinSize({ ...node, position: { x: SP_PAD + colOffset, y: SP_PAD + rowOffset } });
   });
   const positionedBoundaries = repositionBoundaryEvents(boundaryEvents, positionedChildren);
   return {
@@ -406,8 +470,7 @@ function layoutPool(pool, lanes, content, allEdges) {
       height: h
     };
   }
-  const lanePositionsDistinct = lanes.some((l) => Math.abs(l.position.y) > 10);
-  const sortedLanes = lanePositionsDistinct ? [...lanes].sort((a, b) => a.position.y - b.position.y) : [...lanes];
+  const sortedLanes = [...lanes].sort((a, b) => a.position.y - b.position.y);
   const hasLanes = sortedLanes.length > 0;
   const laneIdSet = new Set(sortedLanes.map((l) => l.id));
   const nodeLaneId = /* @__PURE__ */ new Map();
@@ -456,7 +519,7 @@ function layoutPool(pool, lanes, content, allEdges) {
   for (let c = 0; c <= maxCol; c++) colW.set(c, 0);
   for (const node of mainContent) {
     const c = columns.get(node.id) ?? 0;
-    colW.set(c, Math.max(colW.get(c) ?? 0, nW(node)));
+    colW.set(c, Math.max(colW.get(c) ?? 0, layoutW(node)));
   }
   const colX = /* @__PURE__ */ new Map();
   let cumX = 0;
@@ -483,14 +546,16 @@ function layoutPool(pool, lanes, content, allEdges) {
     const laneId = nodeLaneId.get(node.id) ?? "_pool_";
     const stat = laneStats.get(laneId);
     const lYOff = laneY.get(laneId) ?? 0;
-    const colOffset = (colX.get(c) ?? 0) + (colW.get(c) ?? 120) / 2 - nW(node) / 2;
-    const rowOffset = (r - stat.minRow) * (ROW_HEIGHT + ROW_GAP) + ROW_HEIGHT / 2 - nH(node) / 2;
+    const lw = layoutW(node);
+    const lh = layoutH(node);
+    const colOffset = (colX.get(c) ?? 0) + (colW.get(c) ?? 120) / 2 - lw / 2;
+    const rowOffset = (r - stat.minRow) * (ROW_HEIGHT + ROW_GAP) + ROW_HEIGHT / 2 - lh / 2;
     const contentH_stat = stat.rowCount * ROW_HEIGHT + Math.max(0, stat.rowCount - 1) * ROW_GAP;
     const vertTopOffset = Math.max(LANE_V_PAD, (stat.height - contentH_stat) / 2);
     const isLaneChild = hasLanes && !!node.parentId && node.parentId !== pool.id;
     const x = isLaneChild ? LANE_LABEL_W + LANE_H_PAD + colOffset : POOL_H_PAD + colOffset;
     const y = isLaneChild ? vertTopOffset + rowOffset : lYOff + vertTopOffset + rowOffset;
-    return { ...node, position: { x, y } };
+    return applyLayoutMinSize({ ...node, position: { x, y } });
   });
   const NODE_MIN_GAP = 24;
   const resolvedContent = [...positionedContent];
@@ -499,13 +564,13 @@ function layoutPool(pool, lanes, content, allEdges) {
     for (let k = 1; k < laneNodeIndices.length; k++) {
       const prev = resolvedContent[laneNodeIndices[k - 1].i];
       const curr = resolvedContent[laneNodeIndices[k].i];
-      const prevBottom = prev.position.y + nH(prev);
+      const prevBottom = prev.position.y + layoutH(prev);
       const currTop = curr.position.y;
       const prevTop = prev.position.y;
-      const currBottom = curr.position.y + nH(curr);
+      const currBottom = curr.position.y + layoutH(curr);
       const yOverlap = prevBottom + NODE_MIN_GAP > currTop && currBottom + NODE_MIN_GAP > prevTop;
       if (!yOverlap) continue;
-      const prevRight = prev.position.x + nW(prev);
+      const prevRight = prev.position.x + layoutW(prev);
       if (prevRight + NODE_MIN_GAP > curr.position.x) {
         resolvedContent[laneNodeIndices[k].i] = {
           ...curr,
@@ -542,14 +607,38 @@ function absolutePos(nodeId, byId, cache) {
   cache.set(nodeId, abs);
   return abs;
 }
-function laneOf(node, laneIds) {
-  return node.parentId && laneIds.has(node.parentId) ? node.parentId : void 0;
+function findAncestorNodeId(node, candidateIds, byId) {
+  let current = node;
+  while (current?.parentId) {
+    if (candidateIds.has(current.parentId)) return current.parentId;
+    current = byId.get(current.parentId);
+  }
+  return void 0;
+}
+function laneOf(node, laneIds, byId) {
+  return findAncestorNodeId(node, laneIds, byId);
+}
+function poolOf(node, poolIds, byId) {
+  if (poolIds.has(node.id)) return node.id;
+  return findAncestorNodeId(node, poolIds, byId);
+}
+function nodeRect(node, byId, cache) {
+  const pos = absolutePos(node.id, byId, cache);
+  return { x: pos.x, y: pos.y, width: nW(node), height: nH(node) };
+}
+function rectContainsRect(outer, inner) {
+  return inner.x >= outer.x && inner.y >= outer.y && inner.x + inner.width <= outer.x + outer.width && inner.y + inner.height <= outer.y + outer.height;
 }
 function gapMidX(sAbs, sW, tAbs, tW) {
   const leftRightEdge = Math.min(sAbs.x + sW, tAbs.x + tW);
   const rightLeftEdge = Math.max(sAbs.x, tAbs.x);
   return leftRightEdge < rightLeftEdge ? (leftRightEdge + rightLeftEdge) / 2 : sAbs.x + sW / 2;
 }
+function routeMidX(sAbs, sW, tAbs, tW) {
+  const leftEdge = Math.min(sAbs.x + sW, tAbs.x + tW);
+  const rightEdge = Math.max(sAbs.x, tAbs.x);
+  return leftEdge < rightEdge ? leftEdge + (rightEdge - leftEdge) * 0.35 : sAbs.x + sW / 2;
+}
 var SAME_ROW_THRESHOLD = 15;
 function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
   const byId = new Map(layoutNodes.map((n) => [n.id, n]));
@@ -574,18 +663,9 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
     const tCX = tAbs.x + tW / 2;
     const sCY = sAbs.y + sH / 2;
     const tCY = tAbs.y + tH / 2;
-    const getPool = (nodeId) => {
-      const node = byId.get(nodeId);
-      if (!node) return null;
-      if (poolIds.has(nodeId)) return nodeId;
-      if (node.parentId && poolIds.has(node.parentId)) return node.parentId;
-      if (node.parentId) {
-        const gp = byId.get(node.parentId)?.parentId ?? null;
-        if (gp && poolIds.has(gp)) return gp;
-      }
-      return node.parentId ?? null;
-    };
-    if (getPool(edge.source) !== getPool(edge.target)) {
+    const srcPool = poolOf(src, poolIds, byId) ?? null;
+    const tgtPool = poolOf(tgt, poolIds, byId) ?? null;
+    if (srcPool !== tgtPool) {
       const d = { ...edge.data };
       delete d.routingPoints;
       return { ...edge, data: d };
@@ -594,14 +674,16 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
     if (backEdgeIds.has(edge.id)) {
       const topY = Math.min(sAbs.y, tAbs.y) - BACK_EDGE_CLEARANCE;
       routingPoints = [
-        { x: sCX, y: sAbs.y },
-        { x: sCX, y: topY },
-        { x: tCX, y: topY },
-        { x: tCX, y: tAbs.y + tH }
+        { x: sAbs.x + sW, y: sCY },
+        { x: sAbs.x + sW + EDGE_ROUTE_PAD, y: sCY },
+        { x: sAbs.x + sW + EDGE_ROUTE_PAD, y: topY },
+        { x: tAbs.x - EDGE_ROUTE_PAD, y: topY },
+        { x: tAbs.x - EDGE_ROUTE_PAD, y: tCY },
+        { x: tAbs.x, y: tCY }
       ];
-    } else if (laneOf(src, laneIds) !== laneOf(tgt, laneIds)) {
-      const srcLane = byId.get(src.parentId ?? "");
-      const tgtLane = byId.get(tgt.parentId ?? "");
+    } else if (laneOf(src, laneIds, byId) !== laneOf(tgt, laneIds, byId)) {
+      const srcLane = byId.get(laneOf(src, laneIds, byId) ?? "");
+      const tgtLane = byId.get(laneOf(tgt, laneIds, byId) ?? "");
       if (srcLane && tgtLane && laneIds.has(srcLane.id) && laneIds.has(tgtLane.id)) {
         const goingDown = tAbs.y > sAbs.y;
         const sharedX = gapMidX(sAbs, sW, tAbs, tW);
@@ -609,8 +691,8 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
         const tgtLaneIdx = sortedLanes.findIndex((l) => l.id === tgtLane.id);
         const pts = [];
         if (goingDown) {
-          pts.push({ x: sCX, y: sAbs.y + sH });
-          pts.push({ x: sharedX, y: sAbs.y + sH });
+          pts.push({ x: sAbs.x + sW, y: sCY });
+          pts.push({ x: sharedX, y: sCY });
           const fromIdx = Math.min(srcLaneIdx, tgtLaneIdx);
           const toIdx = Math.max(srcLaneIdx, tgtLaneIdx);
           for (let i = fromIdx; i < toIdx; i++) {
@@ -619,11 +701,12 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
             pts.push({ x: sharedX, y: laneBot });
           }
           const lastY = pts[pts.length - 1].y;
-          pts.push({ x: tCX, y: lastY });
-          pts.push({ x: tCX, y: tAbs.y + tH });
+          pts.push({ x: tAbs.x - EDGE_ROUTE_PAD, y: lastY });
+          pts.push({ x: tAbs.x - EDGE_ROUTE_PAD, y: tCY });
+          pts.push({ x: tAbs.x, y: tCY });
         } else {
-          pts.push({ x: sCX, y: sAbs.y });
-          pts.push({ x: sharedX, y: sAbs.y });
+          pts.push({ x: sAbs.x + sW, y: sCY });
+          pts.push({ x: sharedX, y: sCY });
           const fromIdx = Math.min(srcLaneIdx, tgtLaneIdx);
           const toIdx = Math.max(srcLaneIdx, tgtLaneIdx);
           for (let i = toIdx; i > fromIdx; i--) {
@@ -632,17 +715,18 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
             pts.push({ x: sharedX, y: laneTop });
           }
           const lastY = pts[pts.length - 1].y;
-          pts.push({ x: tCX, y: lastY });
-          pts.push({ x: tCX, y: tAbs.y });
+          pts.push({ x: tAbs.x - EDGE_ROUTE_PAD, y: lastY });
+          pts.push({ x: tAbs.x - EDGE_ROUTE_PAD, y: tCY });
+          pts.push({ x: tAbs.x, y: tCY });
         }
         routingPoints = pts;
       } else {
         const sharedX = gapMidX(sAbs, sW, tAbs, tW);
         routingPoints = [
-          { x: sCX, y: sCY },
+          { x: sAbs.x + sW, y: sCY },
           { x: sharedX, y: sCY },
           { x: sharedX, y: tCY },
-          { x: tCX, y: tCY }
+          { x: tAbs.x, y: tCY }
         ];
       }
     } else if (Math.abs(sCY - tCY) <= SAME_ROW_THRESHOLD) {
@@ -654,19 +738,25 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
       const exitsTop = handle.includes("top");
       const exitsBottom = handle.includes("bottom");
       if (exitsTop || exitsBottom) {
+        const exitY = exitsTop ? sAbs.y : sAbs.y + sH;
+        const entryY = exitsTop ? tAbs.y + tH : tAbs.y;
+        const corridorY = exitsTop ? Math.min(exitY, entryY) - EDGE_ROUTE_PAD : Math.max(exitY, entryY) + EDGE_ROUTE_PAD;
         routingPoints = [
-          { x: sCX, y: exitsTop ? sAbs.y : sAbs.y + sH },
-          { x: sCX, y: tCY },
-          { x: tCX, y: tCY },
-          { x: tCX, y: exitsTop ? tAbs.y + tH : tAbs.y }
+          { x: sCX, y: exitY },
+          { x: sCX, y: corridorY },
+          { x: tCX, y: corridorY },
+          { x: tCX, y: entryY }
         ];
       } else {
-        const midX = gapMidX(sAbs, sW, tAbs, tW);
+        const midX = routeMidX(sAbs, sW, tAbs, tW);
+        const exitX = sAbs.x + sW;
+        const entryX = tAbs.x;
+        const corridorX = Math.max(midX, exitX + EDGE_ROUTE_PAD);
         routingPoints = [
-          { x: sAbs.x + sW, y: sCY },
-          { x: midX, y: sCY },
-          { x: midX, y: tCY },
-          { x: tAbs.x, y: tCY }
+          { x: exitX, y: sCY },
+          { x: corridorX, y: sCY },
+          { x: corridorX, y: tCY },
+          { x: entryX, y: tCY }
         ];
       }
     }
@@ -675,16 +765,19 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
 }
 var ARTIFACT_ABOVE_GAP = 16;
 var ARTIFACT_H_SPACING = 12;
-function positionArtifacts(artifacts, resultNodes, edges) {
+function positionArtifacts(artifacts, resultNodes, edges, originalNodes) {
   if (artifacts.length === 0) return [];
   const byId = new Map(resultNodes.map((n) => [n.id, n]));
   const cache = /* @__PURE__ */ new Map();
   const absPos = (id) => absolutePos(id, byId, cache);
+  const originalById = new Map(originalNodes.map((n) => [n.id, n]));
+  const originalCache = /* @__PURE__ */ new Map();
   const artifactsByNode = /* @__PURE__ */ new Map();
   const ungrouped = [];
+  const groups = [];
   for (const artifact of artifacts) {
     if (artifact.data.elementType === "Group") {
-      ungrouped.push(artifact);
+      groups.push(artifact);
       continue;
     }
     const connEdge = edges.find((e) => {
@@ -722,6 +815,58 @@ function positionArtifacts(artifacts, resultNodes, edges) {
       desiredAbsX += nW(artifact) + ARTIFACT_H_SPACING;
     }
   }
+  const nonArtifactOriginalNodes = originalNodes.filter(
+    (node) => !LAYOUT_ARTIFACT_TYPES.has(node.data.elementType)
+  );
+  for (const group of groups) {
+    const originalGroup = originalById.get(group.id);
+    if (!originalGroup) {
+      positioned.push(group);
+      continue;
+    }
+    const groupRect = nodeRect(originalGroup, originalById, originalCache);
+    const containedOriginalIds = nonArtifactOriginalNodes.filter((node) => node.id !== group.id).filter((node) => {
+      if (node.parentId !== group.parentId) return false;
+      return rectContainsRect(groupRect, nodeRect(node, originalById, originalCache));
+    }).map((node) => node.id);
+    if (containedOriginalIds.length === 0) {
+      positioned.push(group);
+      continue;
+    }
+    const containedLaidOut = containedOriginalIds.map((id) => byId.get(id)).filter((node) => !!node);
+    if (containedLaidOut.length === 0) {
+      positioned.push(group);
+      continue;
+    }
+    const GROUP_PAD_X = 24;
+    const GROUP_PAD_Y = 20;
+    const bounds = containedLaidOut.reduce(
+      (acc, node) => {
+        const rect = nodeRect(node, byId, cache);
+        return {
+          left: Math.min(acc.left, rect.x),
+          top: Math.min(acc.top, rect.y),
+          right: Math.max(acc.right, rect.x + rect.width),
+          bottom: Math.max(acc.bottom, rect.y + rect.height)
+        };
+      },
+      { left: Number.POSITIVE_INFINITY, top: Number.POSITIVE_INFINITY, right: Number.NEGATIVE_INFINITY, bottom: Number.NEGATIVE_INFINITY }
+    );
+    const parentAbsP = group.parentId ? absPos(group.parentId) : { x: 0, y: 0 };
+    positioned.push({
+      ...group,
+      position: {
+        x: bounds.left - GROUP_PAD_X - parentAbsP.x,
+        y: bounds.top - GROUP_PAD_Y - parentAbsP.y
+      },
+      width: bounds.right - bounds.left + GROUP_PAD_X * 2,
+      height: bounds.bottom - bounds.top + GROUP_PAD_Y * 2,
+      measured: {
+        width: bounds.right - bounds.left + GROUP_PAD_X * 2,
+        height: bounds.bottom - bounds.top + GROUP_PAD_Y * 2
+      }
+    });
+  }
   return positioned;
 }
 async function bpmnCustomLayout(nodes, edges) {
@@ -756,7 +901,7 @@ async function bpmnCustomLayout(nodes, edges) {
   if (pools.length === 0) {
     const { bpmnElkLayout: bpmnElkLayout2 } = await import('../elk-QT7H4252.js');
     const elkResult = await bpmnElkLayout2(nodes.filter((n) => !LAYOUT_ARTIFACT_TYPES.has(n.data.elementType)), edges);
-    const posArtifacts = positionArtifacts(artifacts, elkResult.nodes, edges);
+    const posArtifacts = positionArtifacts(artifacts, elkResult.nodes, edges, nodes);
     return { nodes: [...elkResult.nodes, ...posArtifacts], edges: elkResult.edges };
   }
   const poolIds = new Set(pools.map((p) => p.id));
@@ -800,8 +945,9 @@ async function bpmnCustomLayout(nodes, edges) {
   const layoutted = new Set(resultNodes.map((n) => n.id));
   const freeNodes = workingMainNodes.filter((n) => !layoutted.has(n.id));
   if (freeNodes.length > 0) {
+    const freeNodeIds = new Set(freeNodes.map((n) => n.id));
     const freeEdges = edges.filter(
-      (e) => freeNodes.some((n) => n.id === e.source || n.id === e.target)
+      (e) => freeNodeIds.has(e.source) && freeNodeIds.has(e.target)
     );
     try {
       const { bpmnElkLayout: bpmnElkLayout2 } = await import('../elk-QT7H4252.js');
@@ -825,7 +971,7 @@ async function bpmnCustomLayout(nodes, edges) {
     }
   }
   const routedEdges = routeEdges(edges, resultNodes, allBackEdgeIds, allLaneIds, poolIds);
-  const positionedArtifacts = positionArtifacts(artifacts, resultNodes, edges);
+  const positionedArtifacts = positionArtifacts(artifacts, resultNodes, edges, nodes);
   return {
     nodes: [...resultNodes, ...positionedArtifacts],
     edges: routedEdges