@aranzatech/diagrams-bpmn 0.3.4 → 0.3.6

package/dist/layout/index.js

@@ -1,10 +1,166 @@
-export { bpmnElkLayout } from '../chunk-FFWJA5BV.js';
-import { getBpmnNodeSize } from '../chunk-YAYZW45I.js';
+import { getBpmnNodeSize } from '../chunk-SRUWPELT.js';
 import '../chunk-RLAJNRF2.js';
 import '../chunk-L5Z22RLX.js';
-import { dagreLayout, applyLayoutResultToDiagram } from '@aranzatech/diagrams-core/layout';
+import { elkLayout, dagreLayout, applyLayoutResultToDiagram } from '@aranzatech/diagrams-core/layout';
 export { applyLayoutResultToDiagram } from '@aranzatech/diagrams-core/layout';
 
+var BPMN_CONTAINER_TYPES = /* @__PURE__ */ new Set([
+  "Pool",
+  "Lane",
+  "SubProcess",
+  "Transaction",
+  "EventSubProcess",
+  "AdHocSubProcess"
+]);
+var CONTAINER_MIN_SIZE = {
+  Pool: { w: 720, h: 200 },
+  Lane: { w: 600, h: 160 },
+  SubProcess: { w: 240, h: 140 },
+  Transaction: { w: 240, h: 140 },
+  EventSubProcess: { w: 240, h: 140 },
+  AdHocSubProcess: { w: 240, h: 140 }
+};
+var CONTAINER_PADDING = {
+  Pool: "[top=30,left=60,bottom=30,right=50]",
+  Lane: "[top=40,left=70,bottom=40,right=50]",
+  SubProcess: "[top=30,left=40,bottom=30,right=40]",
+  Transaction: "[top=30,left=40,bottom=30,right=40]",
+  EventSubProcess: "[top=30,left=40,bottom=30,right=40]",
+  AdHocSubProcess: "[top=30,left=40,bottom=30,right=40]"
+};
+async function bpmnElkLayout(nodes, edges) {
+  const poolsWithLanes = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    if (node.data.elementType === "Lane" && node.parentId) {
+      poolsWithLanes.add(node.parentId);
+    }
+  }
+  const result = await elkLayout(
+    nodes,
+    edges,
+    {
+      direction: "LR",
+      getNodeSize: (node) => {
+        const bNode = node;
+        if (BPMN_CONTAINER_TYPES.has(bNode.data.elementType)) return void 0;
+        return getBpmnNodeSize(bNode);
+      },
+      isContainerNode: (node) => BPMN_CONTAINER_TYPES.has(node.data.elementType),
+      getNodeLayoutOptions: (node) => {
+        const bNode = node;
+        const type = bNode.data.elementType;
+        if (!BPMN_CONTAINER_TYPES.has(type)) return void 0;
+        const min = CONTAINER_MIN_SIZE[type];
+        const isPoolWithLanes = type === "Pool" && poolsWithLanes.has(node.id);
+        const dir = isPoolWithLanes ? "DOWN" : "RIGHT";
+        return {
+          "elk.direction": dir,
+          "elk.nodeSize.constraints": "MINIMUM_SIZE",
+          // Each container handles its own layout pass so cross-lane edges
+          // participate in the internal layout without the global direction
+          // forcing Lane containers to align sideways.
+          "elk.hierarchyHandling": "INCLUDE_CHILDREN",
+          // Lanes within a Pool share a border — zero gap between them.
+          // Other containers keep the tighter inner spacing.
+          ...isPoolWithLanes ? { "elk.spacing.nodeNode": "0", "elk.spacing.componentComponent": "0" } : {
+            "elk.layered.spacing.nodeNodeBetweenLayers": "100",
+            "elk.layered.spacing.edgeNodeBetweenLayers": "45",
+            "elk.spacing.nodeNode": "50"
+          },
+          ...min ? { "elk.nodeSize.minimum": `[w=${min.w},h=${min.h}]` } : {},
+          ...CONTAINER_PADDING[type] ? { "elk.padding": CONTAINER_PADDING[type] } : {}
+        };
+      },
+      elk: {
+        "elk.algorithm": "layered",
+        "elk.direction": "RIGHT",
+        // INHERIT: each container handles its own INCLUDE_CHILDREN pass so
+        // the global RIGHT direction does not force Lane containers sideways.
+        "elk.hierarchyHandling": "INHERIT",
+        "elk.edgeRouting": "ORTHOGONAL",
+        // Global spacing — generous values for visual breathing room.
+        "elk.layered.spacing.nodeNodeBetweenLayers": "120",
+        "elk.layered.spacing.edgeNodeBetweenLayers": "50",
+        "elk.spacing.nodeNode": "70",
+        "elk.spacing.componentComponent": "100"
+      }
+    }
+  );
+  const nodeMap = new Map(result.nodes.map((n) => [n.id, n]));
+  const edgeMap = new Map(result.edges.map((e) => [e.id, e]));
+  const COMPONENT_GAP = 100;
+  const rootNodeOrder = nodes.filter((n) => !n.parentId).map((n) => n.id);
+  const rootHeights = /* @__PURE__ */ new Map();
+  for (const id of rootNodeOrder) {
+    const laid = nodeMap.get(id);
+    const orig = nodes.find((n) => n.id === id);
+    rootHeights.set(id, laid?.height ?? orig?.height ?? 200);
+  }
+  let stackY = 0;
+  const rootY = /* @__PURE__ */ new Map();
+  for (const id of rootNodeOrder) {
+    rootY.set(id, stackY);
+    stackY += (rootHeights.get(id) ?? 200) + COMPONENT_GAP;
+  }
+  const updatedNodes = nodes.map((node) => {
+    const laid = nodeMap.get(node.id);
+    if (!laid) return node;
+    const pos = node.parentId ? laid.position : { x: laid.position.x, y: rootY.get(node.id) ?? laid.position.y };
+    return { ...node, position: pos, width: laid.width, height: laid.height };
+  });
+  const lanesByPool = /* @__PURE__ */ new Map();
+  for (const node of updatedNodes) {
+    if (node.data.elementType === "Lane" && node.parentId) {
+      const arr = lanesByPool.get(node.parentId) ?? [];
+      arr.push(node.id);
+      lanesByPool.set(node.parentId, arr);
+    }
+  }
+  const nodeIndex = new Map(updatedNodes.map((n, i) => [n.id, i]));
+  for (const laneIds of lanesByPool.values()) {
+    const widths = laneIds.map((id) => updatedNodes[nodeIndex.get(id)]?.width ?? 0);
+    const maxWidth = Math.max(...widths);
+    if (maxWidth <= 0) continue;
+    for (const id of laneIds) {
+      const idx = nodeIndex.get(id);
+      if (idx !== void 0) {
+        updatedNodes[idx] = { ...updatedNodes[idx], width: maxWidth };
+      }
+    }
+  }
+  const nodeRootContainer = /* @__PURE__ */ new Map();
+  for (const node of updatedNodes) {
+    nodeRootContainer.set(node.id, node.parentId ?? null);
+  }
+  const getRootContainer = (nodeId) => {
+    let current = nodeId;
+    const visited = /* @__PURE__ */ new Set();
+    while (current) {
+      if (visited.has(current)) break;
+      visited.add(current);
+      const parent = nodeRootContainer.get(current);
+      if (!parent) return current;
+      current = parent;
+    }
+    return null;
+  };
+  const updatedEdges = edges.map((edge) => {
+    const laid = edgeMap.get(edge.id);
+    if (!laid) return edge;
+    const nextData = { ...edge.data };
+    const sourceRoot = getRootContainer(edge.source);
+    const targetRoot = getRootContainer(edge.target);
+    const isCrossPool = sourceRoot !== targetRoot;
+    if (!isCrossPool && laid.points && laid.points.length > 0) {
+      nextData.routingPoints = laid.points;
+    } else {
+      delete nextData.routingPoints;
+    }
+    return { ...edge, data: nextData };
+  });
+  return { nodes: updatedNodes, edges: updatedEdges };
+}
+
 // src/layout/bpmn-layout-graph.ts
 var LAYOUT_CONTAINER_TYPES = /* @__PURE__ */ new Set([
   "Pool",
@@ -22,15 +178,21 @@ var LAYOUT_GATEWAY_TYPES = /* @__PURE__ */ new Set([
   "ComplexGateway"
 ]);
 function detectBackEdges(nodeIds, seqEdges) {
+  const sortedIds = [...nodeIds].sort();
   const backEdgeIds = /* @__PURE__ */ new Set();
   const state = /* @__PURE__ */ new Map();
-  for (const id of nodeIds) state.set(id, 0);
+  for (const id of sortedIds) state.set(id, 0);
   const adj = /* @__PURE__ */ new Map();
-  for (const id of nodeIds) adj.set(id, []);
+  for (const id of sortedIds) adj.set(id, []);
   for (const e of seqEdges) {
     adj.get(e.source)?.push({ target: e.target, edgeId: e.id });
   }
-  for (const startId of nodeIds) {
+  for (const list of adj.values()) {
+    list.sort(
+      (a, b) => a.target < b.target ? -1 : a.target > b.target ? 1 : a.edgeId < b.edgeId ? -1 : a.edgeId > b.edgeId ? 1 : 0
+    );
+  }
+  for (const startId of sortedIds) {
     if (state.get(startId) !== 0) continue;
     const stack = [{ id: startId, idx: 0 }];
     state.set(startId, 1);
@@ -107,9 +269,7 @@ function detectGatewayPairs(nodes, forwardEdges) {
   }
   const order = topologicalSort(nodeIds, forwardEdges);
   const topoPos = new Map(order.map((id, i) => [id, i]));
-  const splits = nodes.filter(
-    (n) => LAYOUT_GATEWAY_TYPES.has(n.data.elementType) && (succs.get(n.id)?.length ?? 0) > 1
-  );
+  const splits = nodes.filter((n) => (succs.get(n.id)?.length ?? 0) > 1);
   for (const split of splits) {
     const branches = succs.get(split.id) ?? [];
     if (branches.length < 2) continue;
@@ -161,12 +321,18 @@ function buildHandleMap(edges) {
   }
   return map;
 }
+function branchPullBias(nodeIds, nodeBias) {
+  if (!nodeBias) return null;
+  let sum = 0;
+  for (const id of nodeIds) sum += nodeBias.get(id) ?? 0;
+  if (sum === 0) return null;
+  return sum > 0 ? 1 : -1;
+}
 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;
+    const rank = (branch) => branch.bias === 0 ? 2 : branch.bias === null ? 1 : 0;
+    if (rank(a) !== rank(b)) return rank(b) - rank(a);
     if (a.nodeIds.length !== b.nodeIds.length) return b.nodeIds.length - a.nodeIds.length;
     return a.start.localeCompare(b.start);
   })[0]?.start;
@@ -207,7 +373,7 @@ function assignBranchRowsAroundMain(branchData, splitRow) {
   }
   return assigned;
 }
-function assignRows(nodes, forwardEdges, columns, gatewayPairs) {
+function assignRows(nodes, forwardEdges, columns, gatewayPairs, nodeBias) {
   const rows = new Map(nodes.map((n) => [n.id, 0]));
   const succs = new Map(nodes.map((n) => [n.id, []]));
   for (const e of forwardEdges) {
@@ -215,7 +381,7 @@ function assignRows(nodes, forwardEdges, columns, gatewayPairs) {
   }
   const handleMap = buildHandleMap(forwardEdges);
   const sortedPairs = [...gatewayPairs.entries()].sort(
-    (a, b) => (columns.get(b[0]) ?? 0) - (columns.get(a[0]) ?? 0)
+    (a, b) => (columns.get(a[0]) ?? 0) - (columns.get(b[0]) ?? 0)
   );
   for (const [splitId, mergeId] of sortedPairs) {
     const branches = succs.get(splitId) ?? [];
@@ -235,11 +401,14 @@ function assignRows(nodes, forwardEdges, columns, gatewayPairs) {
       return result;
     };
     const splitHandles = handleMap.get(splitId);
-    const branchData = branches.map((start) => ({
-      start,
-      nodeIds: getBranchNodes(start),
-      bias: handleToRowBias(splitHandles?.get(start) ?? null)
-    }));
+    const branchData = branches.map((start) => {
+      const nodeIds = getBranchNodes(start);
+      return {
+        start,
+        nodeIds,
+        bias: handleToRowBias(splitHandles?.get(start) ?? null) ?? branchPullBias(nodeIds, nodeBias)
+      };
+    });
     const assigned = assignBranchRowsAroundMain(branchData, splitRow);
     for (const b of branchData) {
       const row = assigned.get(b.start) ?? splitRow;
@@ -251,7 +420,7 @@ function assignRows(nodes, forwardEdges, columns, gatewayPairs) {
   }
   const pairedSplits = new Set(gatewayPairs.keys());
   const unpairedSplits = nodes.filter(
-    (n) => LAYOUT_GATEWAY_TYPES.has(n.data.elementType) && !pairedSplits.has(n.id) && (succs.get(n.id)?.length ?? 0) > 1
+    (n) => !pairedSplits.has(n.id) && (succs.get(n.id)?.length ?? 0) > 1
   );
   for (const split of unpairedSplits) {
     const branches = succs.get(split.id) ?? [];
@@ -271,11 +440,14 @@ function assignRows(nodes, forwardEdges, columns, gatewayPairs) {
       return result;
     };
     const splitHandles2 = handleMap.get(split.id);
-    const branchData = branches.map((start) => ({
-      start,
-      nodeIds: getAllReachable(start),
-      bias: handleToRowBias(splitHandles2?.get(start) ?? null)
-    }));
+    const branchData = branches.map((start) => {
+      const nodeIds = getAllReachable(start);
+      return {
+        start,
+        nodeIds,
+        bias: handleToRowBias(splitHandles2?.get(start) ?? null) ?? branchPullBias(nodeIds, nodeBias)
+      };
+    });
     const assigned2 = assignBranchRowsAroundMain(branchData, splitRow);
     for (const b of branchData) {
       const row = assigned2.get(b.start) ?? splitRow;
@@ -328,6 +500,17 @@ var LAYOUT_TASK_TYPES = /* @__PURE__ */ new Set([
 ]);
 var TASK_LAYOUT_MIN_W = 130;
 var TASK_LAYOUT_MIN_H = 80;
+var SUBPROCESS_LAYOUT_MIN_W = 160;
+var SUBPROCESS_LAYOUT_MIN_H = 80;
+function layoutMinSize(node) {
+  if (LAYOUT_TASK_TYPES.has(node.data.elementType)) {
+    return { w: TASK_LAYOUT_MIN_W, h: TASK_LAYOUT_MIN_H };
+  }
+  if (COLLAPSED_SUBPROCESS_TYPES.has(node.data.elementType) && !node.data.isExpanded) {
+    return { w: SUBPROCESS_LAYOUT_MIN_W, h: SUBPROCESS_LAYOUT_MIN_H };
+  }
+  return null;
+}
 function nW(node) {
   return node.width ?? node.measured?.width ?? 120;
 }
@@ -335,18 +518,68 @@ 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);
+  const min = layoutMinSize(node);
+  return min ? Math.max(nW(node), 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);
+  const min = layoutMinSize(node);
+  return min ? Math.max(nH(node), min.h) : nH(node);
+}
+var LABEL_RESERVE_TYPES = /* @__PURE__ */ new Set([
+  ...LAYOUT_GATEWAY_TYPES,
+  "StartEvent",
+  "EndEvent",
+  "IntermediateCatchEvent",
+  "IntermediateThrowEvent"
+]);
+var LABEL_CHAR_W = 6.5;
+var LABEL_RESERVE_MAX = 150;
+function columnW(node) {
+  const base = layoutW(node);
+  if (!LABEL_RESERVE_TYPES.has(node.data.elementType)) return base;
+  const label = typeof node.data.label === "string" ? node.data.label : "";
+  if (!label) return base;
+  const reserve = Math.min(Math.ceil(label.length * LABEL_CHAR_W), LABEL_RESERVE_MAX);
+  return Math.max(base, reserve);
 }
 function applyLayoutMinSize(node) {
-  if (!LAYOUT_TASK_TYPES.has(node.data.elementType)) return node;
+  if (!layoutMinSize(node)) 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 } };
 }
+function computeRowMetrics(contextNodes, rows, includeRowZero) {
+  const vals = contextNodes.map((n) => rows.get(n.id) ?? 0);
+  const base = includeRowZero ? [0, ...vals] : vals;
+  const minRow = Math.min(...base);
+  const maxRow = Math.max(...base);
+  const rowH = /* @__PURE__ */ new Map();
+  for (let r = minRow; r <= maxRow; r++) rowH.set(r, ROW_HEIGHT);
+  for (const node of contextNodes) {
+    const r = rows.get(node.id) ?? 0;
+    rowH.set(r, Math.max(rowH.get(r) ?? ROW_HEIGHT, layoutH(node)));
+  }
+  const rowY = /* @__PURE__ */ new Map();
+  let y = 0;
+  for (let r = minRow; r <= maxRow; r++) {
+    rowY.set(r, y);
+    y += (rowH.get(r) ?? ROW_HEIGHT) + ROW_GAP;
+  }
+  return { minRow, maxRow, rowH, rowY, contentH: y - ROW_GAP };
+}
+function reanchorBoundaryEdges(edges, boundaryEvents, contentIds) {
+  if (boundaryEvents.length === 0) return edges;
+  const hostByBoundaryId = /* @__PURE__ */ new Map();
+  for (const be of boundaryEvents) {
+    if (be.data.attachedToRef) hostByBoundaryId.set(be.id, be.data.attachedToRef);
+  }
+  if (hostByBoundaryId.size === 0) return edges;
+  return edges.map((edge) => {
+    const host = hostByBoundaryId.get(edge.source);
+    return host && contentIds.has(host) ? { ...edge, source: host, sourceHandle: "source-bottom" } : edge;
+  });
+}
 var BOUNDARY_SPACING = 10;
 function repositionBoundaryEvents(boundaryEvents, positionedContent) {
   if (boundaryEvents.length === 0) return [];
@@ -403,7 +636,8 @@ function layoutSubProcess(children, edges) {
     };
   }
   const contentIds = new Set(mainChildren.map((n) => n.id));
-  const seqEdges = extractSeqEdges(edges, contentIds);
+  const graphEdges = reanchorBoundaryEdges(edges, boundaryEvents, contentIds);
+  const seqEdges = extractSeqEdges(graphEdges, contentIds);
   const backIds = detectBackEdges([...contentIds], seqEdges);
   const fwdEdges = seqEdges.filter((e) => !backIds.has(e.id));
   const columns = assignColumns([...contentIds], fwdEdges);
@@ -414,7 +648,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, layoutW(node)));
+    colW.set(c, Math.max(colW.get(c) ?? 0, columnW(node)));
   }
   const colX = /* @__PURE__ */ new Map();
   let cumX = 0;
@@ -423,20 +657,16 @@ function layoutSubProcess(children, edges) {
     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 rowMetrics = computeRowMetrics(mainChildren, rows, true);
   const spW = Math.max(280, SP_PAD * 2 + contentW);
-  const spH = Math.max(160, SP_PAD * 2 + contentH);
+  const spH = Math.max(160, SP_PAD * 2 + rowMetrics.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;
+    const rowOffset = (rowMetrics.rowY.get(r) ?? 0) + (rowMetrics.rowH.get(r) ?? ROW_HEIGHT) / 2 - lh / 2;
     return applyLayoutMinSize({ ...node, position: { x: SP_PAD + colOffset, y: SP_PAD + rowOffset } });
   });
   const positionedBoundaries = repositionBoundaryEvents(boundaryEvents, positionedChildren);
@@ -479,7 +709,8 @@ function layoutPool(pool, lanes, content, allEdges) {
     nodeLaneId.set(node.id, lId);
   }
   const contentIds = new Set(mainContent.map((n) => n.id));
-  const seqEdges = extractSeqEdges(allEdges, contentIds);
+  const graphEdges = reanchorBoundaryEdges(allEdges, boundaryEvents, contentIds);
+  const seqEdges = extractSeqEdges(graphEdges, contentIds);
   const backIds = detectBackEdges([...contentIds], seqEdges);
   const fwdEdges = seqEdges.filter((e) => !backIds.has(e.id));
   const columns = assignColumns([...contentIds], fwdEdges);
@@ -490,47 +721,107 @@ function layoutPool(pool, lanes, content, allEdges) {
     if (!contentByLane.has(lId)) contentByLane.set(lId, []);
     contentByLane.get(lId).push(node);
   }
+  const laneStackIndex = /* @__PURE__ */ new Map();
+  sortedLanes.forEach((laneNode, index) => laneStackIndex.set(laneNode.id, index));
+  laneStackIndex.set("_pool_", sortedLanes.length);
+  const crossLanePull = /* @__PURE__ */ new Map();
+  for (const e of fwdEdges) {
+    const sLane = nodeLaneId.get(e.source) ?? "_pool_";
+    const tLane = nodeLaneId.get(e.target) ?? "_pool_";
+    if (sLane === tLane) continue;
+    const dir = Math.sign((laneStackIndex.get(tLane) ?? 0) - (laneStackIndex.get(sLane) ?? 0));
+    crossLanePull.set(e.source, (crossLanePull.get(e.source) ?? 0) + dir);
+    crossLanePull.set(e.target, (crossLanePull.get(e.target) ?? 0) - dir);
+  }
   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);
+    const laneRows = assignRows(laneNodes, intraEdges, columns, lanePairs, crossLanePull);
     for (const [id, row] of laneRows) rows.set(id, row);
   }
-  const laneIds = hasLanes ? sortedLanes.map((l) => l.id) : ["_pool_"];
+  const seqTouched = /* @__PURE__ */ new Set();
+  for (const e of seqEdges) {
+    seqTouched.add(e.source);
+    seqTouched.add(e.target);
+  }
+  for (const [, laneNodes] of contentByLane) {
+    const eventSPs = laneNodes.filter(
+      (n) => n.data.elementType === "EventSubProcess" && !seqTouched.has(n.id)
+    );
+    if (eventSPs.length === 0) continue;
+    const eventSpIds = new Set(eventSPs.map((n) => n.id));
+    const otherRows = laneNodes.filter((n) => !eventSpIds.has(n.id)).map((n) => rows.get(n.id) ?? 0);
+    const laneMaxRow = otherRows.length > 0 ? Math.max(...otherRows) : -1;
+    for (const sp of eventSPs) rows.set(sp.id, laneMaxRow + 1);
+  }
+  const hasPoolDirectContent = [...nodeLaneId.values()].includes("_pool_");
+  const laneIds = hasLanes ? [...sortedLanes.map((l) => l.id), ...hasPoolDirectContent ? ["_pool_"] : []] : ["_pool_"];
   const laneStats = /* @__PURE__ */ new Map();
   for (const laneId of laneIds) {
-    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 });
+    const laneNodes = mainContent.filter((n) => nodeLaneId.get(n.id) === laneId);
+    if (laneNodes.length === 0) {
+      laneStats.set(laneId, {
+        minRow: 0,
+        maxRow: 0,
+        height: LANE_MIN_H,
+        contentH: ROW_HEIGHT,
+        rowH: /* @__PURE__ */ new Map([[0, ROW_HEIGHT]]),
+        rowY: /* @__PURE__ */ new Map([[0, 0]])
+      });
     } else {
-      const minRow = Math.min(...laneRows);
-      const maxRow = Math.max(...laneRows);
-      const rowCount = maxRow - minRow + 1;
-      const contentH = rowCount * ROW_HEIGHT + Math.max(0, rowCount - 1) * ROW_GAP;
-      const height = Math.max(LANE_MIN_H, LANE_V_PAD * 2 + contentH);
-      laneStats.set(laneId, { minRow, maxRow, rowCount, height });
+      const m = computeRowMetrics(laneNodes, rows, false);
+      const height = Math.max(LANE_MIN_H, LANE_V_PAD * 2 + m.contentH);
+      laneStats.set(laneId, {
+        minRow: m.minRow,
+        maxRow: m.maxRow,
+        height,
+        contentH: m.contentH,
+        rowH: m.rowH,
+        rowY: m.rowY
+      });
     }
   }
-  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 mainContent) {
-    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 laneColumnLayouts = /* @__PURE__ */ new Map();
+  for (const laneId of laneIds) {
+    const laneNodes = mainContent.filter(
+      (node) => (nodeLaneId.get(node.id) ?? "_pool_") === laneId
+    );
+    const usedCols = [...new Set(laneNodes.map((node) => columns.get(node.id) ?? 0))].sort((a, b) => a - b);
+    const colW = /* @__PURE__ */ new Map();
+    for (const col of usedCols) colW.set(col, 0);
+    for (const node of laneNodes) {
+      const col = columns.get(node.id) ?? 0;
+      colW.set(col, Math.max(colW.get(col) ?? 0, columnW(node)));
+    }
+    const colX = /* @__PURE__ */ new Map();
+    let laneCumX = 0;
+    for (const col of usedCols) {
+      colX.set(col, laneCumX);
+      laneCumX += (colW.get(col) ?? 120) + COL_GAP;
+    }
+    laneColumnLayouts.set(laneId, {
+      colW,
+      colX,
+      contentW: usedCols.length > 0 ? laneCumX - COL_GAP : 0
+    });
   }
-  const contentW = cumX - COL_GAP;
-  const innerW = LANE_LABEL_W + LANE_H_PAD + contentW + LANE_H_PAD;
+  const baseLaneInnerW = Math.max(
+    0,
+    ...laneIds.filter((laneId) => laneId !== "_pool_").map((laneId) => {
+      const contentW = laneColumnLayouts.get(laneId)?.contentW ?? 0;
+      return LANE_LABEL_W + LANE_H_PAD + contentW + LANE_H_PAD;
+    })
+  );
+  const basePoolInnerW = Math.max(
+    0,
+    ...laneIds.filter((laneId) => laneId === "_pool_").map((laneId) => (laneColumnLayouts.get(laneId)?.contentW ?? 0) + POOL_H_PAD * 2)
+  );
+  const innerW = Math.max(baseLaneInnerW, basePoolInnerW);
   const poolW = Math.max(POOL_MIN_W, innerW + POOL_INNER_PAD * 2);
-  const laneW = poolW - POOL_INNER_PAD * 2;
+  let laneW = poolW - POOL_INNER_PAD * 2;
   const laneY = /* @__PURE__ */ new Map();
   let cumY = POOL_INNER_PAD;
   for (let i = 0; i < laneIds.length; i++) {
@@ -545,20 +836,106 @@ function layoutPool(pool, lanes, content, allEdges) {
     const r = rows.get(node.id) ?? 0;
     const laneId = nodeLaneId.get(node.id) ?? "_pool_";
     const stat = laneStats.get(laneId);
+    const laneLayout = laneColumnLayouts.get(laneId);
     const lYOff = laneY.get(laneId) ?? 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 - 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 colOffset = (laneLayout?.colX.get(c) ?? 0) + (laneLayout?.colW.get(c) ?? 120) / 2 - lw / 2;
+    const rowOffset = (stat.rowY.get(r) ?? 0) + (stat.rowH.get(r) ?? ROW_HEIGHT) / 2 - lh / 2;
+    const vertTopOffset = Math.max(LANE_V_PAD, (stat.height - stat.contentH) / 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 applyLayoutMinSize({ ...node, position: { x, y } });
   });
+  const handoffAdjustedContent = [...positionedContent];
+  const nodeIndexById = new Map(handoffAdjustedContent.map((node, index) => [node.id, index]));
+  const outgoingBySource = /* @__PURE__ */ new Map();
+  for (const edge of fwdEdges) {
+    if (!outgoingBySource.has(edge.source)) outgoingBySource.set(edge.source, []);
+    outgoingBySource.get(edge.source).push(edge);
+  }
+  const crossLaneEdges = fwdEdges.filter((edge) => {
+    const srcLane = nodeLaneId.get(edge.source) ?? "_pool_";
+    const tgtLane = nodeLaneId.get(edge.target) ?? "_pool_";
+    return srcLane !== tgtLane;
+  }).sort(
+    (a, b) => (columns.get(a.target) ?? 0) - (columns.get(b.target) ?? 0) || (columns.get(a.source) ?? 0) - (columns.get(b.source) ?? 0)
+  );
+  for (const edge of crossLaneEdges) {
+    const srcIndex = nodeIndexById.get(edge.source);
+    const tgtIndex = nodeIndexById.get(edge.target);
+    if (srcIndex == null || tgtIndex == null) continue;
+    const srcNode = handoffAdjustedContent[srcIndex];
+    const tgtNode = handoffAdjustedContent[tgtIndex];
+    const tgtLaneId = nodeLaneId.get(tgtNode.id) ?? "_pool_";
+    const tgtCol = columns.get(tgtNode.id) ?? 0;
+    const siblingTargets = (outgoingBySource.get(edge.source) ?? []).filter((candidate) => (columns.get(candidate.target) ?? 0) === tgtCol).map((candidate) => handoffAdjustedContent[nodeIndexById.get(candidate.target) ?? -1]).filter((node) => !!node);
+    const siblingAlignedX = siblingTargets.reduce(
+      (max, node) => Math.max(max, node.position.x),
+      Number.NEGATIVE_INFINITY
+    );
+    const minTargetX = Math.max(
+      siblingAlignedX,
+      srcNode.position.x + layoutW(srcNode) / 2 + layoutW(tgtNode) / 2 + COL_GAP
+    );
+    if (tgtNode.position.x >= minTargetX) continue;
+    const delta = minTargetX - tgtNode.position.x;
+    for (let i = 0; i < handoffAdjustedContent.length; i++) {
+      const candidate = handoffAdjustedContent[i];
+      if ((nodeLaneId.get(candidate.id) ?? "_pool_") !== tgtLaneId) continue;
+      if ((columns.get(candidate.id) ?? 0) < tgtCol) continue;
+      handoffAdjustedContent[i] = {
+        ...candidate,
+        position: {
+          x: candidate.position.x + delta,
+          y: candidate.position.y
+        }
+      };
+    }
+  }
+  for (const [sourceId, outgoing] of outgoingBySource) {
+    if (outgoing.length < 2) continue;
+    const hasCrossLaneSibling = outgoing.some((edge) => {
+      const srcLane = nodeLaneId.get(edge.source) ?? "_pool_";
+      const tgtLane = nodeLaneId.get(edge.target) ?? "_pool_";
+      return srcLane !== tgtLane;
+    });
+    if (!hasCrossLaneSibling) continue;
+    const siblingsByCol = /* @__PURE__ */ new Map();
+    for (const edge of outgoing) {
+      const col = columns.get(edge.target) ?? 0;
+      const node = handoffAdjustedContent[nodeIndexById.get(edge.target) ?? -1];
+      if (!node) continue;
+      if (!siblingsByCol.has(col)) siblingsByCol.set(col, []);
+      siblingsByCol.get(col).push(node);
+    }
+    for (const [col, siblings] of siblingsByCol) {
+      if (siblings.length < 2) continue;
+      const alignedX = Math.max(...siblings.map((node) => node.position.x));
+      for (let i = 0; i < handoffAdjustedContent.length; i++) {
+        const candidate = handoffAdjustedContent[i];
+        if (!siblings.some((node) => node.id === candidate.id)) continue;
+        const laneId = nodeLaneId.get(candidate.id) ?? "_pool_";
+        for (let j = 0; j < handoffAdjustedContent.length; j++) {
+          const maybeShift = handoffAdjustedContent[j];
+          if ((nodeLaneId.get(maybeShift.id) ?? "_pool_") !== laneId) continue;
+          if ((columns.get(maybeShift.id) ?? 0) < col) continue;
+          const delta = alignedX - candidate.position.x;
+          if (delta <= 0) continue;
+          handoffAdjustedContent[j] = {
+            ...maybeShift,
+            position: {
+              x: maybeShift.position.x + delta,
+              y: maybeShift.position.y
+            }
+          };
+        }
+      }
+    }
+  }
   const NODE_MIN_GAP = 24;
-  const resolvedContent = [...positionedContent];
+  const resolvedContent = [...handoffAdjustedContent];
   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++) {
@@ -580,6 +957,15 @@ function layoutPool(pool, lanes, content, allEdges) {
     }
   }
   const positionedBoundaries = repositionBoundaryEvents(boundaryEvents, resolvedContent);
+  const laneChildRight = resolvedContent.filter((node) => hasLanes && !!node.parentId && node.parentId !== pool.id).reduce((max, node) => Math.max(max, node.position.x + nW(node) + LANE_H_PAD), 0);
+  const poolChildRight = resolvedContent.filter((node) => !hasLanes || !node.parentId || node.parentId === pool.id).reduce((max, node) => Math.max(max, node.position.x + nW(node) + POOL_H_PAD), 0);
+  const boundaryRight = positionedBoundaries.reduce(
+    (max, node) => Math.max(max, node.position.x + nW(node) + (hasLanes ? LANE_H_PAD : POOL_H_PAD)),
+    0
+  );
+  const finalInnerW = Math.max(innerW, laneChildRight, poolChildRight, boundaryRight);
+  const finalPoolW = Math.max(POOL_MIN_W, finalInnerW + POOL_INNER_PAD * 2);
+  laneW = finalPoolW - POOL_INNER_PAD * 2;
   const positionedLanes = hasLanes ? sortedLanes.map((lane) => ({
     ...lane,
     position: { x: POOL_INNER_PAD, y: laneY.get(lane.id) ?? POOL_INNER_PAD },
@@ -588,10 +974,21 @@ function layoutPool(pool, lanes, content, allEdges) {
   })) : [];
   return {
     nodes: [...resolvedContent, ...positionedBoundaries, ...positionedLanes],
-    width: poolW,
+    width: finalPoolW,
     height: poolH
   };
 }
+function layoutVirtualContext(contextNodes, allEdges, offsetY) {
+  if (contextNodes.length === 0) return [];
+  const virtualPool = {
+    id: "__bpmn_virtual_pool__"};
+  const result = layoutPool(virtualPool, [], contextNodes, allEdges);
+  if (offsetY === 0) return result.nodes;
+  return result.nodes.map((n) => ({
+    ...n,
+    position: { x: n.position.x, y: n.position.y + offsetY }
+  }));
+}
 function absolutePos(nodeId, byId, cache) {
   const cached = cache.get(nodeId);
   if (cached) return cached;
@@ -672,9 +1069,75 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
   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 contentInfos = layoutNodes.filter((n) => !poolIds.has(n.id) && !laneIds.has(n.id)).map((n) => {
+    const p = abs(n.id);
+    return { id: n.id, x: p.x, y: p.y, w: nW(n), h: nH(n), poolId: poolOf(n, poolIds, byId) ?? null };
+  });
+  const findClearX = (desiredX, y0, y1, minX, maxX, excludeA, excludeB, poolId) => {
+    if (minX > maxX) return desiredX;
+    const clampX = (x) => Math.min(maxX, Math.max(minX, x));
+    const blockers = contentInfos.filter(
+      (c) => c.poolId === poolId && c.id !== excludeA && c.id !== excludeB && c.y < y1 && c.y + c.h > y0
+    );
+    const isFree = (x) => blockers.every((c) => x < c.x - 4 || x > c.x + c.w + 4);
+    const clamped = clampX(desiredX);
+    if (isFree(clamped)) return clamped;
+    const candidates = [];
+    for (const c of blockers) candidates.push(c.x - 8, c.x + c.w + 8);
+    const free = candidates.map(clampX).filter(isFree).sort((a, b) => Math.abs(a - desiredX) - Math.abs(b - desiredX));
+    return free.length > 0 ? free[0] : clamped;
+  };
+  const backEdgeOrder = /* @__PURE__ */ new Map();
+  for (const edge of [...edges].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0)) {
+    if (backEdgeIds.has(edge.id)) backEdgeOrder.set(edge.id, backEdgeOrder.size);
+  }
+  const routeMessageFlow = (edge) => {
+    const src = byId.get(edge.source);
+    const tgt = byId.get(edge.target);
+    if (!src || !tgt) return null;
+    const srcPoolId = poolOf(src, poolIds, byId);
+    const tgtPoolId = poolOf(tgt, poolIds, byId);
+    if (!srcPoolId || !tgtPoolId || srcPoolId === tgtPoolId) return null;
+    const srcPoolNode = byId.get(srcPoolId);
+    const tgtPoolNode = byId.get(tgtPoolId);
+    if (!srcPoolNode || !tgtPoolNode) return null;
+    const sAbs = abs(src.id);
+    const tAbs = abs(tgt.id);
+    const sCX = sAbs.x + nW(src) / 2;
+    const tCX = tAbs.x + nW(tgt) / 2;
+    const srcPoolAbs = abs(srcPoolId);
+    const tgtPoolAbs = abs(tgtPoolId);
+    const srcPoolBottom = srcPoolAbs.y + nH(srcPoolNode);
+    const tgtPoolBottom = tgtPoolAbs.y + nH(tgtPoolNode);
+    if (tgtPoolAbs.y >= srcPoolBottom) {
+      const corridorY = (srcPoolBottom + tgtPoolAbs.y) / 2;
+      return [
+        { x: sCX, y: sAbs.y + nH(src) },
+        { x: sCX, y: corridorY },
+        { x: tCX, y: corridorY },
+        { x: tCX, y: tAbs.y }
+      ];
+    }
+    if (srcPoolAbs.y >= tgtPoolBottom) {
+      const corridorY = (tgtPoolBottom + srcPoolAbs.y) / 2;
+      return [
+        { x: sCX, y: sAbs.y },
+        { x: sCX, y: corridorY },
+        { x: tCX, y: corridorY },
+        { x: tCX, y: tAbs.y + nH(tgt) }
+      ];
+    }
+    return null;
+  };
+  const routed = edges.map((edge) => {
     const edgeType = edge.data?.edgeType ?? edge.type;
     if (edgeType !== "sequenceFlow") {
+      if (edgeType === "messageFlow") {
+        const pts = routeMessageFlow(edge);
+        if (pts) {
+          return { ...edge, data: { ...edge.data, routingPoints: pts } };
+        }
+      }
       const d = { ...edge.data };
       delete d.routingPoints;
       return { ...edge, data: d };
@@ -699,7 +1162,16 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
     }
     let routingPoints;
     if (backEdgeIds.has(edge.id)) {
-      const topY = Math.min(sAbs.y, tAbs.y) - BACK_EDGE_CLEARANCE;
+      const spanMinX = Math.min(tAbs.x, sAbs.x) - EDGE_ROUTE_PAD;
+      const spanMaxX = Math.max(tAbs.x + tW, sAbs.x + sW) + EDGE_ROUTE_PAD;
+      let topMost = Math.min(sAbs.y, tAbs.y);
+      for (const cand of contentInfos) {
+        if (cand.poolId !== srcPool) continue;
+        if (cand.x + cand.w < spanMinX || cand.x > spanMaxX) continue;
+        topMost = Math.min(topMost, cand.y);
+      }
+      const stagger = (backEdgeOrder.get(edge.id) ?? 0) * 14;
+      const topY = topMost - BACK_EDGE_CLEARANCE - stagger;
       routingPoints = [
         { x: sAbs.x + sW, y: sCY },
         { x: sAbs.x + sW + EDGE_ROUTE_PAD, y: sCY },
@@ -713,7 +1185,16 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
       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);
+        const sharedX = findClearX(
+          gapMidX(sAbs, sW, tAbs, tW),
+          Math.min(sCY, tCY),
+          Math.max(sCY, tCY),
+          sAbs.x + sW + 6,
+          tAbs.x - EDGE_ROUTE_PAD - 4,
+          src.id,
+          tgt.id,
+          srcPool
+        );
         const srcLaneIdx = sortedLanes.findIndex((l) => l.id === srcLane.id);
         const tgtLaneIdx = sortedLanes.findIndex((l) => l.id === tgtLane.id);
         const pts = [];
@@ -748,7 +1229,16 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
         }
         routingPoints = pts;
       } else {
-        const sharedX = gapMidX(sAbs, sW, tAbs, tW);
+        const sharedX = findClearX(
+          gapMidX(sAbs, sW, tAbs, tW),
+          Math.min(sCY, tCY),
+          Math.max(sCY, tCY),
+          sAbs.x + sW + 6,
+          tAbs.x - 6,
+          src.id,
+          tgt.id,
+          srcPool
+        );
         routingPoints = [
           { x: sAbs.x + sW, y: sCY },
           { x: sharedX, y: sCY },
@@ -778,7 +1268,16 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
         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);
+        const corridorX = findClearX(
+          Math.max(midX, exitX + EDGE_ROUTE_PAD),
+          Math.min(sCY, tCY),
+          Math.max(sCY, tCY),
+          exitX + 6,
+          entryX - 6,
+          src.id,
+          tgt.id,
+          srcPool
+        );
         routingPoints = [
           { x: exitX, y: sCY },
           { x: corridorX, y: sCY },
@@ -789,9 +1288,81 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
     }
     return { ...edge, data: { ...edge.data, routingPoints } };
   });
+  return spreadVerticalChannels(routed);
+}
+var CHANNEL_GAP = 10;
+var CHANNEL_CLUSTER_TOL = 8;
+function spreadVerticalChannels(edges) {
+  const runs = [];
+  edges.forEach((edge, edgeIdx) => {
+    const pts = edge.data?.routingPoints;
+    if (!pts || pts.length < 4) return;
+    let i = 1;
+    while (i < pts.length) {
+      let j = i;
+      while (j < pts.length && Math.abs(pts[j].x - pts[j - 1].x) <= 0.5) j++;
+      if (j > i) {
+        const fromIdx = i - 1;
+        const toIdx = j - 1;
+        if (fromIdx > 0 && toIdx < pts.length - 1) {
+          const ys = pts.slice(fromIdx, toIdx + 1).map((p) => p.y);
+          const y0 = Math.min(...ys);
+          const y1 = Math.max(...ys);
+          if (y1 - y0 >= 4) {
+            runs.push({ edgeIdx, fromIdx, toIdx, x: pts[fromIdx].x, y0, y1 });
+          }
+        }
+        i = j + 1;
+      } else {
+        i++;
+      }
+    }
+  });
+  if (runs.length < 2) return edges;
+  runs.sort((a, b) => a.x - b.x);
+  const clusters = [];
+  for (const run of runs) {
+    const last = clusters[clusters.length - 1];
+    if (last && run.x - last[0].x <= CHANNEL_CLUSTER_TOL) last.push(run);
+    else clusters.push([run]);
+  }
+  const offsets = /* @__PURE__ */ new Map();
+  for (const cluster of clusters) {
+    if (cluster.length < 2) continue;
+    const colliding = cluster.filter(
+      (run) => cluster.some((other) => other !== run && run.y0 < other.y1 && other.y0 < run.y1)
+    );
+    if (colliding.length < 2) continue;
+    const ordered = [...colliding].sort((a, b) => {
+      const idA = edges[a.edgeIdx].id;
+      const idB = edges[b.edgeIdx].id;
+      return idA < idB ? -1 : idA > idB ? 1 : a.fromIdx - b.fromIdx;
+    });
+    ordered.forEach((run, k) => {
+      const off = Math.round((k - (ordered.length - 1) / 2) * CHANNEL_GAP);
+      if (off !== 0) offsets.set(run, off);
+    });
+  }
+  if (offsets.size === 0) return edges;
+  const runsByEdge = /* @__PURE__ */ new Map();
+  for (const [run, off] of offsets) {
+    if (!runsByEdge.has(run.edgeIdx)) runsByEdge.set(run.edgeIdx, []);
+    runsByEdge.get(run.edgeIdx).push(run);
+  }
+  return edges.map((edge, edgeIdx) => {
+    const edgeRuns = runsByEdge.get(edgeIdx);
+    if (!edgeRuns) return edge;
+    const pts = (edge.data?.routingPoints).map((p) => ({ ...p }));
+    for (const run of edgeRuns) {
+      const off = offsets.get(run);
+      for (let p = run.fromIdx; p <= run.toIdx; p++) pts[p].x += off;
+    }
+    return { ...edge, data: { ...edge.data, routingPoints: pts } };
+  });
 }
 var ARTIFACT_ABOVE_GAP = 16;
 var ARTIFACT_H_SPACING = 12;
+var ARTIFACT_EDGE_PAD = 4;
 function positionArtifacts(artifacts, resultNodes, edges, originalNodes) {
   if (artifacts.length === 0) return [];
   const byId = new Map(resultNodes.map((n) => [n.id, n]));
@@ -832,11 +1403,21 @@ function positionArtifacts(artifacts, resultNodes, edges, originalNodes) {
     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 };
+      let relY = desiredAbsY - parentAbsP.y;
+      const parentNode = artifact.parentId ? byId.get(artifact.parentId) : void 0;
+      if (parentNode) {
+        if (relY < ARTIFACT_EDGE_PAD) {
+          const belowAbsY = connAbsP.y + nH(connNode) + ARTIFACT_ABOVE_GAP;
+          relY = belowAbsY - parentAbsP.y;
+        }
+        relY = Math.min(relY, nH(parentNode) - nH(artifact) - ARTIFACT_EDGE_PAD);
+        relY = Math.max(relY, ARTIFACT_EDGE_PAD);
+      }
       positioned.push({
         ...artifact,
         position: {
           x: desiredAbsX - parentAbsP.x,
-          y: desiredAbsY - parentAbsP.y
+          y: relY
         }
       });
       desiredAbsX += nW(artifact) + ARTIFACT_H_SPACING;
@@ -901,9 +1482,17 @@ async function bpmnCustomLayout(nodes, edges) {
   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 nodeDepthById = /* @__PURE__ */ new Map();
+  const mainById = new Map(mainNodes.map((n) => [n.id, n]));
+  const depthOf = (node) => {
+    const cached = nodeDepthById.get(node.id);
+    if (cached != null) return cached;
+    const parent = node.parentId ? mainById.get(node.parentId) : void 0;
+    const depth = parent ? depthOf(parent) + 1 : 0;
+    nodeDepthById.set(node.id, depth);
+    return depth;
+  };
+  const expandedSubProcesses = mainNodes.filter((n) => COLLAPSED_SUBPROCESS_TYPES.has(n.data.elementType) && n.data.isExpanded).sort((a, b) => depthOf(b) - depthOf(a));
   const subProcessLayouts = /* @__PURE__ */ new Map();
   const workingMainNodes = [...mainNodes];
   for (const sp of expandedSubProcesses) {
@@ -921,15 +1510,30 @@ async function bpmnCustomLayout(nodes, edges) {
     }
   }
   const content = workingMainNodes.filter((n) => {
+    if (n.data.elementType === "BoundaryEvent") return false;
     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 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, nodes);
-    return { nodes: sortNodesParentFirst([...elkResult.nodes, ...posArtifacts]), edges: elkResult.edges };
+    const isSpChild = (n) => !!n.parentId && subProcessLayouts.has(n.parentId);
+    const freeContent = content.filter((n) => !isSpChild(n));
+    const freeBoundaries = workingMainNodes.filter(
+      (n) => n.data.elementType === "BoundaryEvent" && !isSpChild(n)
+    );
+    const resultNodes2 = layoutVirtualContext([...freeContent, ...freeBoundaries], edges, 0);
+    for (const [, spLayout] of subProcessLayouts) {
+      for (const child of spLayout.children) resultNodes2.push(child);
+    }
+    const contentIds = new Set(freeContent.map((n) => n.id));
+    const seqEdges = extractSeqEdges(edges, contentIds);
+    const backIds = detectBackEdges([...contentIds], seqEdges);
+    const routedEdges2 = routeEdges(edges, resultNodes2, backIds, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set());
+    const posArtifacts = positionArtifacts(artifacts, resultNodes2, edges, nodes);
+    return {
+      nodes: sortNodesParentFirst([...resultNodes2, ...posArtifacts]),
+      edges: routedEdges2
+    };
   }
   const poolIds = new Set(pools.map((p) => p.id));
   const allLaneIds = new Set(lanes.map((l) => l.id));
@@ -972,30 +1576,14 @@ 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) => freeNodeIds.has(e.source) && freeNodeIds.has(e.target)
+    const freeFlow = freeNodes.filter(
+      (n) => n.data.elementType === "BoundaryEvent" || !LAYOUT_CONTAINER_TYPES.has(n.data.elementType) || COLLAPSED_SUBPROCESS_TYPES.has(n.data.elementType)
     );
-    try {
-      const { bpmnElkLayout: bpmnElkLayout2 } = await import('../elk-QT7H4252.js');
-      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 freeRest = freeNodes.filter((n) => !freeFlow.includes(n));
+    for (const node of layoutVirtualContext(freeFlow, edges, stackY)) {
+      resultNodes.push(node);
     }
+    for (const node of freeRest) resultNodes.push(node);
   }
   const routedEdges = routeEdges(edges, resultNodes, allBackEdgeIds, allLaneIds, poolIds);
   const positionedArtifacts = positionArtifacts(artifacts, resultNodes, edges, nodes);
@@ -1016,6 +1604,6 @@ function applyBpmnLayoutResult(state, result) {
   return applyLayoutResultToDiagram(state, result);
 }
 
-export { applyBpmnLayoutResult, bpmnCustomLayout, bpmnDagreLayout };
+export { applyBpmnLayoutResult, bpmnCustomLayout, bpmnDagreLayout, bpmnElkLayout };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map