@aranzatech/diagrams-bpmn 0.3.0 → 0.3.2

package/dist/layout/index.cjs

@@ -1311,63 +1311,221 @@ function assignRows(nodes, forwardEdges, columns, gatewayPairs) {
 
 // src/layout/bpmn-custom-layout.ts
 var LANE_LABEL_W = 28;
-var LANE_H_PAD = 20;
-var COL_GAP = 80;
-var ROW_HEIGHT = 80;
-var ROW_GAP = 60;
-var LANE_V_PAD = 50;
-var POOL_H_PAD = 60;
-var POOL_V_GAP = 50;
-var LANE_MIN_H = 160;
+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 = 8;
+var POOL_INNER_PAD = 10;
+var BACK_EDGE_CLEARANCE = 56;
+var LAYOUT_ARTIFACT_TYPES = /* @__PURE__ */ new Set([
+  "DataObject",
+  "DataObjectReference",
+  "DataInput",
+  "DataOutput",
+  "DataStore",
+  "DataStoreReference",
+  "Annotation",
+  "Group"
+]);
+var COLLAPSED_SUBPROCESS_TYPES = /* @__PURE__ */ new Set([
+  "SubProcess",
+  "Transaction",
+  "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 [];
+  const hostById = new Map(positionedContent.map((n) => [n.id, n]));
+  const byHost = /* @__PURE__ */ new Map();
+  for (const be of boundaryEvents) {
+    const hostId = be.data.attachedToRef;
+    if (!hostId) continue;
+    if (!byHost.has(hostId)) byHost.set(hostId, []);
+    byHost.get(hostId).push(be);
+  }
+  const result = [];
+  for (const be of boundaryEvents) {
+    const hostId = be.data.attachedToRef;
+    if (!hostId) {
+      result.push(be);
+      continue;
+    }
+    const host = hostById.get(hostId);
+    if (!host) {
+      result.push(be);
+      continue;
+    }
+    const hostGroup = byHost.get(hostId);
+    const siblingIdx = hostGroup.findIndex((n) => n.id === be.id);
+    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;
+    const offsetX = hostGroup.slice(0, siblingIdx).reduce((s, b) => s + nW(b) + BOUNDARY_SPACING, 0);
+    result.push({
+      ...be,
+      position: {
+        x: groupStartX + offsetX,
+        y: host.position.y + hostH - beH / 2
+      }
+    });
+  }
+  return result;
+}
+var SP_PAD = 48;
+function layoutSubProcess(children, edges) {
+  if (children.length === 0) {
+    return { children: [], width: 280, height: 160 };
+  }
+  const boundaryEvents = children.filter((n) => n.data.elementType === "BoundaryEvent");
+  const mainChildren = children.filter((n) => n.data.elementType !== "BoundaryEvent");
+  if (mainChildren.length === 0) {
+    return {
+      children: repositionBoundaryEvents(boundaryEvents, []),
+      width: 280,
+      height: 160
+    };
+  }
+  const contentIds = new Set(mainChildren.map((n) => n.id));
+  const seqEdges = extractSeqEdges(edges, contentIds);
+  const backIds = detectBackEdges([...contentIds], seqEdges);
+  const fwdEdges = seqEdges.filter((e) => !backIds.has(e.id));
+  const columns = assignColumns([...contentIds], fwdEdges);
+  const pairs = detectGatewayPairs(mainChildren, fwdEdges);
+  const rows = assignRows(mainChildren, fwdEdges, columns, pairs);
+  const maxCol = Math.max(0, ...[...columns.values()]);
+  const colW = /* @__PURE__ */ new Map();
+  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, layoutW(node)));
+  }
+  const colX = /* @__PURE__ */ new Map();
+  let cumX = 0;
+  for (let c = 0; c <= maxCol; c++) {
+    colX.set(c, cumX);
+    cumX += (colW.get(c) ?? 120) + COL_GAP;
+  }
+  const contentW = cumX - COL_GAP;
+  const rowVals = [...rows.values()];
+  const minRow = Math.min(0, ...rowVals);
+  const maxRow = Math.max(0, ...rowVals);
+  const rowCount = maxRow - minRow + 1;
+  const contentH = rowCount * ROW_HEIGHT + Math.max(0, rowCount - 1) * ROW_GAP;
+  const spW = Math.max(280, SP_PAD * 2 + contentW);
+  const spH = Math.max(160, SP_PAD * 2 + contentH);
+  const positionedChildren = mainChildren.map((node) => {
+    const c = columns.get(node.id) ?? 0;
+    const r = rows.get(node.id) ?? 0;
+    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 {
+    children: [...positionedChildren, ...positionedBoundaries],
+    width: spW,
+    height: spH
+  };
+}
 function layoutPool(pool, lanes, content, allEdges) {
-  if (content.length === 0) {
+  const boundaryEvents = content.filter((n) => n.data.elementType === "BoundaryEvent");
+  const mainContent = content.filter((n) => n.data.elementType !== "BoundaryEvent");
+  if (mainContent.length === 0) {
+    const positionedBoundaries2 = repositionBoundaryEvents(boundaryEvents, []);
     if (lanes.length === 0) {
-      return { nodes: [], width: 240, height: 120 };
+      return { nodes: positionedBoundaries2, width: 300, height: 140 };
     }
     const laneH = LANE_MIN_H;
     const h = POOL_INNER_PAD * 2 + lanes.length * laneH + Math.max(0, lanes.length - 1) * POOL_INNER_PAD;
-    const w = POOL_MIN_W;
     return {
-      nodes: lanes.map((lane, i) => ({
-        ...lane,
-        position: { x: POOL_INNER_PAD, y: POOL_INNER_PAD + i * (laneH + POOL_INNER_PAD) },
-        width: w - POOL_INNER_PAD * 2,
-        height: laneH
-      })),
-      width: w,
+      nodes: [
+        ...positionedBoundaries2,
+        ...lanes.map((lane, i) => ({
+          ...lane,
+          position: { x: POOL_INNER_PAD, y: POOL_INNER_PAD + i * (laneH + POOL_INNER_PAD) },
+          width: POOL_MIN_W - POOL_INNER_PAD * 2,
+          height: laneH
+        }))
+      ],
+      width: POOL_MIN_W,
       height: h
     };
   }
-  const contentIds = new Set(content.map((n) => n.id));
+  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();
+  for (const node of mainContent) {
+    const lId = hasLanes && node.parentId && laneIdSet.has(node.parentId) ? node.parentId : "_pool_";
+    nodeLaneId.set(node.id, lId);
+  }
+  const contentIds = new Set(mainContent.map((n) => n.id));
   const seqEdges = extractSeqEdges(allEdges, contentIds);
   const backIds = detectBackEdges([...contentIds], seqEdges);
   const fwdEdges = seqEdges.filter((e) => !backIds.has(e.id));
   const columns = assignColumns([...contentIds], fwdEdges);
-  const pairs = detectGatewayPairs(content, fwdEdges);
-  const rows = assignRows(content, fwdEdges, columns, pairs);
-  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 hasLanes = sortedLanes.length > 0;
-  const nodeLaneId = /* @__PURE__ */ new Map();
-  for (const node of content) {
-    if (hasLanes && node.parentId && node.parentId !== pool.id) {
-      nodeLaneId.set(node.id, node.parentId);
-    } else {
-      nodeLaneId.set(node.id, "_pool_");
-    }
+  const rows = /* @__PURE__ */ new Map();
+  const contentByLane = /* @__PURE__ */ new Map();
+  for (const node of mainContent) {
+    const lId = nodeLaneId.get(node.id) ?? "_pool_";
+    if (!contentByLane.has(lId)) contentByLane.set(lId, []);
+    contentByLane.get(lId).push(node);
+  }
+  for (const [, laneNodes] of contentByLane) {
+    const laneNodeIds = new Set(laneNodes.map((n) => n.id));
+    const intraEdges = fwdEdges.filter(
+      (e) => laneNodeIds.has(e.source) && laneNodeIds.has(e.target)
+    );
+    const lanePairs = detectGatewayPairs(laneNodes, intraEdges);
+    const laneRows = assignRows(laneNodes, intraEdges, columns, lanePairs);
+    for (const [id, row] of laneRows) rows.set(id, row);
   }
   const laneIds = hasLanes ? sortedLanes.map((l) => l.id) : ["_pool_"];
   const laneStats = /* @__PURE__ */ new Map();
   for (const laneId of laneIds) {
-    const laneRows = content.filter((n) => nodeLaneId.get(n.id) === laneId).map((n) => rows.get(n.id) ?? 0);
+    const laneRows = mainContent.filter((n) => nodeLaneId.get(n.id) === laneId).map((n) => rows.get(n.id) ?? 0);
     if (laneRows.length === 0) {
       laneStats.set(laneId, { minRow: 0, maxRow: 0, rowCount: 1, height: LANE_MIN_H });
     } else {
@@ -1382,9 +1540,9 @@ function layoutPool(pool, lanes, content, allEdges) {
   const maxCol = Math.max(0, ...[...columns.values()]);
   const colW = /* @__PURE__ */ new Map();
   for (let c = 0; c <= maxCol; c++) colW.set(c, 0);
-  for (const node of content) {
+  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;
@@ -1405,62 +1563,58 @@ function layoutPool(pool, lanes, content, allEdges) {
     if (i < laneIds.length - 1) cumY += POOL_INNER_PAD;
   }
   const poolH = cumY + POOL_INNER_PAD;
-  const positionedContent = content.map((node) => {
+  const positionedContent = mainContent.map((node) => {
     const c = columns.get(node.id) ?? 0;
     const r = rows.get(node.id) ?? 0;
     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 isLaneChild = hasLanes && !!node.parentId && node.parentId !== pool.id;
+    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 = 20;
+  const NODE_MIN_GAP = 24;
   const resolvedContent = [...positionedContent];
   for (const laneId of laneIds) {
     const laneNodeIndices = resolvedContent.map((n, i) => ({ n, i })).filter(({ n }) => (nodeLaneId.get(n.id) ?? "_pool_") === laneId).sort((a, b) => a.n.position.x - b.n.position.x);
     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,
-          position: {
-            x: prevRight + NODE_MIN_GAP,
-            y: curr.position.y
-          }
+          position: { x: prevRight + NODE_MIN_GAP, y: curr.position.y }
         };
       }
     }
   }
+  const positionedBoundaries = repositionBoundaryEvents(boundaryEvents, resolvedContent);
   const positionedLanes = hasLanes ? sortedLanes.map((lane) => ({
     ...lane,
-    // x: after pool label strip + left inner padding
-    // y: laneY already includes top POOL_INNER_PAD offset
     position: { x: POOL_INNER_PAD, y: laneY.get(lane.id) ?? POOL_INNER_PAD },
     width: laneW,
     height: laneStats.get(lane.id)?.height ?? LANE_MIN_H
   })) : [];
   return {
-    nodes: [...resolvedContent, ...positionedLanes],
+    nodes: [...resolvedContent, ...positionedBoundaries, ...positionedLanes],
     width: poolW,
     height: poolH
   };
 }
-var BACK_EDGE_CLEARANCE = 50;
-var SAME_ROW_THRESHOLD = 15;
 function absolutePos(nodeId, byId, cache) {
   const cached = cache.get(nodeId);
   if (cached) return cached;
@@ -1479,10 +1633,22 @@ function absolutePos(nodeId, byId, cache) {
 function laneOf(node, laneIds) {
   return node.parentId && laneIds.has(node.parentId) ? node.parentId : void 0;
 }
+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]));
   const cache = /* @__PURE__ */ new Map();
   const abs = (id) => absolutePos(id, byId, cache);
+  const sortedLanes = [...laneIds].map((id) => byId.get(id)).filter((n) => !!n).sort((a, b) => abs(a.id).y - abs(b.id).y);
   return edges.map((edge) => {
     const edgeType = edge.data?.edgeType ?? edge.type;
     if (edgeType !== "sequenceFlow") {
@@ -1497,11 +1663,22 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
     const tAbs = abs(tgt.id);
     const sW = nW(src), sH = nH(src);
     const tW = nW(tgt), tH = nH(tgt);
-    const sCX = sAbs.x + sW / 2, sCY = sAbs.y + sH / 2;
-    const tCX = tAbs.x + tW / 2, tCY = tAbs.y + tH / 2;
-    const srcPool = poolIds.has(src.parentId ?? "") ? src.parentId : poolIds.has(byId.get(src.parentId ?? "")?.parentId ?? "") ? byId.get(src.parentId ?? "")?.parentId : src.parentId;
-    const tgtPool = poolIds.has(tgt.parentId ?? "") ? tgt.parentId : poolIds.has(byId.get(tgt.parentId ?? "")?.parentId ?? "") ? byId.get(tgt.parentId ?? "")?.parentId : tgt.parentId;
-    if (srcPool !== tgtPool) {
+    const sCX = sAbs.x + sW / 2;
+    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 d = { ...edge.data };
       delete d.routingPoints;
       return { ...edge, data: d };
@@ -1511,33 +1688,49 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
       const topY = Math.min(sAbs.y, tAbs.y) - BACK_EDGE_CLEARANCE;
       routingPoints = [
         { x: sCX, y: sAbs.y },
-        // [0] discarded
         { x: sCX, y: topY },
-        // [1] go up
         { x: tCX, y: topY },
-        // [2] go left/right
-        { x: tCX, y: tAbs.y }
-        // [3] discarded
+        { x: tCX, y: tAbs.y + tH }
       ];
     } else if (laneOf(src, laneIds) !== laneOf(tgt, laneIds)) {
-      const goingDown = tAbs.y > sAbs.y;
-      const sharedX = Math.abs(sCX - tCX) < 10 ? sCX : (sCX + tCX) / 2;
       const srcLane = byId.get(src.parentId ?? "");
       const tgtLane = byId.get(tgt.parentId ?? "");
       if (srcLane && tgtLane && laneIds.has(srcLane.id) && laneIds.has(tgtLane.id)) {
-        const srcLaneAbs = abs(srcLane.id);
-        const borderY = goingDown ? srcLaneAbs.y + (srcLane.height ?? 160) : srcLaneAbs.y;
-        routingPoints = [
-          { x: sCX, y: goingDown ? sAbs.y + sH : sAbs.y },
-          // [0] discarded
-          { x: sharedX, y: goingDown ? sAbs.y + sH : sAbs.y },
-          // [1] bend: horizontal exit
-          { x: sharedX, y: borderY },
-          // [2] bend: lane border
-          { x: sharedX, y: goingDown ? tAbs.y : tAbs.y + tH }
-          // [3] discarded
-        ];
+        const goingDown = tAbs.y > sAbs.y;
+        const sharedX = gapMidX(sAbs, sW, tAbs, tW);
+        const srcLaneIdx = sortedLanes.findIndex((l) => l.id === srcLane.id);
+        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 });
+          const fromIdx = Math.min(srcLaneIdx, tgtLaneIdx);
+          const toIdx = Math.max(srcLaneIdx, tgtLaneIdx);
+          for (let i = fromIdx; i < toIdx; i++) {
+            const lane = sortedLanes[i];
+            const laneBot = abs(lane.id).y + (lane.height ?? LANE_MIN_H);
+            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 });
+        } else {
+          pts.push({ x: sCX, y: sAbs.y });
+          pts.push({ x: sharedX, y: sAbs.y });
+          const fromIdx = Math.min(srcLaneIdx, tgtLaneIdx);
+          const toIdx = Math.max(srcLaneIdx, tgtLaneIdx);
+          for (let i = toIdx; i > fromIdx; i--) {
+            const lane = sortedLanes[i];
+            const laneTop = abs(lane.id).y;
+            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 });
+        }
+        routingPoints = pts;
       } else {
+        const sharedX = gapMidX(sAbs, sW, tAbs, tW);
         routingPoints = [
           { x: sCX, y: sCY },
           { x: sharedX, y: sCY },
@@ -1556,39 +1749,108 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
       if (exitsTop || exitsBottom) {
         routingPoints = [
           { x: sCX, y: exitsTop ? sAbs.y : sAbs.y + sH },
-          // [0] discarded
           { x: sCX, y: tCY },
-          // [1] vertical to target row
           { x: tCX, y: tCY },
-          // [2] horizontal to target
           { x: tCX, y: exitsTop ? tAbs.y + tH : tAbs.y }
-          // [3] discarded
         ];
       } else {
-        const goingRight = tAbs.x >= sAbs.x;
-        const midX = goingRight ? sAbs.x + sW + COL_GAP / 2 : sAbs.x - COL_GAP / 2;
+        const midX = routeMidX(sAbs, sW, tAbs, tW);
         routingPoints = [
           { x: sAbs.x + sW, y: sCY },
-          // [0] discarded
           { x: midX, y: sCY },
-          // [1] horizontal exit
           { x: midX, y: tCY },
-          // [2] vertical to target row
           { x: tAbs.x, y: tCY }
-          // [3] discarded
         ];
       }
     }
     return { ...edge, data: { ...edge.data, routingPoints } };
   });
 }
+var ARTIFACT_ABOVE_GAP = 16;
+var ARTIFACT_H_SPACING = 12;
+function positionArtifacts(artifacts, resultNodes, edges) {
+  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 artifactsByNode = /* @__PURE__ */ new Map();
+  const ungrouped = [];
+  for (const artifact of artifacts) {
+    if (artifact.data.elementType === "Group") {
+      ungrouped.push(artifact);
+      continue;
+    }
+    const connEdge = edges.find((e) => {
+      const t = e.data?.edgeType ?? e.type;
+      return (t === "association" || t === "dataAssociation") && (e.source === artifact.id || e.target === artifact.id);
+    });
+    if (!connEdge) {
+      ungrouped.push(artifact);
+      continue;
+    }
+    const connId = connEdge.source === artifact.id ? connEdge.target : connEdge.source;
+    if (!byId.has(connId)) {
+      ungrouped.push(artifact);
+      continue;
+    }
+    if (!artifactsByNode.has(connId)) artifactsByNode.set(connId, []);
+    artifactsByNode.get(connId).push(artifact);
+  }
+  const positioned = [...ungrouped];
+  for (const [connId, arts] of artifactsByNode) {
+    const connNode = byId.get(connId);
+    const connAbsP = absPos(connId);
+    const totalW = arts.reduce((s, a) => s + nW(a), 0) + (arts.length - 1) * ARTIFACT_H_SPACING;
+    const desiredAbsY = connAbsP.y - ARTIFACT_ABOVE_GAP - Math.max(...arts.map(nH));
+    let desiredAbsX = connAbsP.x + nW(connNode) / 2 - totalW / 2;
+    for (const artifact of arts) {
+      const parentAbsP = artifact.parentId ? absPos(artifact.parentId) : { x: 0, y: 0 };
+      positioned.push({
+        ...artifact,
+        position: {
+          x: desiredAbsX - parentAbsP.x,
+          y: desiredAbsY - parentAbsP.y
+        }
+      });
+      desiredAbsX += nW(artifact) + ARTIFACT_H_SPACING;
+    }
+  }
+  return positioned;
+}
 async function bpmnCustomLayout(nodes, edges) {
-  const pools = nodes.filter((n) => n.data.elementType === "Pool");
-  const lanes = nodes.filter((n) => n.data.elementType === "Lane");
-  const content = nodes.filter((n) => !LAYOUT_CONTAINER_TYPES.has(n.data.elementType));
+  const artifacts = nodes.filter((n) => LAYOUT_ARTIFACT_TYPES.has(n.data.elementType));
+  const mainNodes = nodes.filter((n) => !LAYOUT_ARTIFACT_TYPES.has(n.data.elementType));
+  const pools = mainNodes.filter((n) => n.data.elementType === "Pool");
+  const lanes = mainNodes.filter((n) => n.data.elementType === "Lane");
+  const expandedSubProcesses = mainNodes.filter(
+    (n) => COLLAPSED_SUBPROCESS_TYPES.has(n.data.elementType) && n.data.isExpanded
+  );
+  const subProcessLayouts = /* @__PURE__ */ new Map();
+  const workingMainNodes = [...mainNodes];
+  for (const sp of expandedSubProcesses) {
+    const spChildren = workingMainNodes.filter((n) => n.parentId === sp.id);
+    const result = layoutSubProcess(spChildren, edges);
+    subProcessLayouts.set(sp.id, result);
+    const spIdx = workingMainNodes.findIndex((n) => n.id === sp.id);
+    if (spIdx >= 0) {
+      workingMainNodes[spIdx] = {
+        ...workingMainNodes[spIdx],
+        width: result.width,
+        height: result.height,
+        measured: { width: result.width, height: result.height }
+      };
+    }
+  }
+  const content = workingMainNodes.filter((n) => {
+    if (!LAYOUT_CONTAINER_TYPES.has(n.data.elementType)) return true;
+    if (COLLAPSED_SUBPROCESS_TYPES.has(n.data.elementType)) return true;
+    return false;
+  });
   if (pools.length === 0) {
     const { bpmnElkLayout: bpmnElkLayout2 } = await Promise.resolve().then(() => (init_elk(), elk_exports));
-    return bpmnElkLayout2(nodes, edges);
+    const elkResult = await bpmnElkLayout2(nodes.filter((n) => !LAYOUT_ARTIFACT_TYPES.has(n.data.elementType)), edges);
+    const posArtifacts = positionArtifacts(artifacts, elkResult.nodes, edges);
+    return { nodes: [...elkResult.nodes, ...posArtifacts], edges: elkResult.edges };
   }
   const poolIds = new Set(pools.map((p) => p.id));
   const allLaneIds = new Set(lanes.map((l) => l.id));
@@ -1608,7 +1870,10 @@ async function bpmnCustomLayout(nodes, edges) {
     const poolContent = content.filter(
       (n) => n.parentId === pool.id || n.parentId != null && laneIds.has(n.parentId)
     );
-    const result = layoutPool(pool, poolLanes, poolContent, edges);
+    const poolBoundaries = workingMainNodes.filter(
+      (n) => n.data.elementType === "BoundaryEvent" && (n.parentId === pool.id || n.parentId != null && laneIds.has(n.parentId))
+    );
+    const result = layoutPool(pool, poolLanes, [...poolContent, ...poolBoundaries], edges);
     resultNodes.push({
       ...pool,
       position: { x: 0, y: stackY },
@@ -1620,12 +1885,44 @@ async function bpmnCustomLayout(nodes, edges) {
     }
     stackY += result.height + POOL_V_GAP;
   }
+  for (const [, spLayout] of subProcessLayouts) {
+    for (const child of spLayout.children) {
+      resultNodes.push(child);
+    }
+  }
   const layoutted = new Set(resultNodes.map((n) => n.id));
-  for (const node of nodes) {
-    if (!layoutted.has(node.id)) resultNodes.push(node);
+  const freeNodes = workingMainNodes.filter((n) => !layoutted.has(n.id));
+  if (freeNodes.length > 0) {
+    const freeEdges = edges.filter(
+      (e) => freeNodes.some((n) => n.id === e.source || n.id === e.target)
+    );
+    try {
+      const { bpmnElkLayout: bpmnElkLayout2 } = await Promise.resolve().then(() => (init_elk(), elk_exports));
+      const elkFree = await bpmnElkLayout2(freeNodes, freeEdges);
+      const offsetY = stackY;
+      for (const node of elkFree.nodes) {
+        resultNodes.push({
+          ...node,
+          position: { x: node.position.x, y: node.position.y + offsetY }
+        });
+      }
+      const freeEdgeIds = new Set(freeEdges.map((e) => e.id));
+      const elkEdgeMap = new Map(elkFree.edges.map((e) => [e.id, e]));
+      for (let i = 0; i < edges.length; i++) {
+        if (freeEdgeIds.has(edges[i].id) && elkEdgeMap.has(edges[i].id)) {
+          edges[i] = elkEdgeMap.get(edges[i].id);
+        }
+      }
+    } catch {
+      for (const node of freeNodes) resultNodes.push(node);
+    }
   }
   const routedEdges = routeEdges(edges, resultNodes, allBackEdgeIds, allLaneIds, poolIds);
-  return { nodes: resultNodes, edges: routedEdges };
+  const positionedArtifacts = positionArtifacts(artifacts, resultNodes, edges);
+  return {
+    nodes: [...resultNodes, ...positionedArtifacts],
+    edges: routedEdges
+  };
 }
 
 // src/layout/index.ts