@aranzatech/diagrams-bpmn 0.2.13 → 0.2.15

package/dist/layout/index.js

@@ -1,10 +1,12 @@
-import { getBpmnNodeSize } from '../chunk-UAWLUDKC.js';
+export { bpmnElkLayout } from '../chunk-XMVV7FRZ.js';
+import { getBpmnNodeSize } from '../chunk-HOWK3ZOO.js';
 import '../chunk-RLAJNRF2.js';
 import '../chunk-L5Z22RLX.js';
-import { elkLayout, dagreLayout, applyLayoutResultToDiagram } from '@aranzatech/diagrams-core/layout';
+import { dagreLayout, applyLayoutResultToDiagram } from '@aranzatech/diagrams-core/layout';
 export { applyLayoutResultToDiagram } from '@aranzatech/diagrams-core/layout';
 
-var BPMN_CONTAINER_TYPES = /* @__PURE__ */ new Set([
+// src/layout/bpmn-layout-graph.ts
+var LAYOUT_CONTAINER_TYPES = /* @__PURE__ */ new Set([
   "Pool",
   "Lane",
   "SubProcess",
@@ -12,83 +14,556 @@ var BPMN_CONTAINER_TYPES = /* @__PURE__ */ new Set([
   "EventSubProcess",
   "AdHocSubProcess"
 ]);
-var CONTAINER_MIN_SIZE = {
-  Pool: { w: 560, h: 160 },
-  Lane: { w: 480, h: 100 },
-  SubProcess: { w: 200, h: 120 },
-  Transaction: { w: 200, h: 120 },
-  EventSubProcess: { w: 200, h: 120 },
-  AdHocSubProcess: { w: 200, h: 120 }
-};
-var CONTAINER_PADDING = {
-  Pool: "[top=30,left=55,bottom=30,right=40]",
-  Lane: "[top=25,left=60,bottom=25,right=40]",
-  SubProcess: "[top=25,left=35,bottom=25,right=35]",
-  Transaction: "[top=25,left=35,bottom=25,right=35]",
-  EventSubProcess: "[top=25,left=35,bottom=25,right=35]",
-  AdHocSubProcess: "[top=25,left=35,bottom=25,right=35]"
-};
-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);
+var LAYOUT_GATEWAY_TYPES = /* @__PURE__ */ new Set([
+  "ExclusiveGateway",
+  "InclusiveGateway",
+  "ParallelGateway",
+  "EventBasedGateway",
+  "ComplexGateway"
+]);
+function detectBackEdges(nodeIds, seqEdges) {
+  const backEdgeIds = /* @__PURE__ */ new Set();
+  const state = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) state.set(id, 0);
+  const adj = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) adj.set(id, []);
+  for (const e of seqEdges) {
+    adj.get(e.source)?.push({ target: e.target, edgeId: e.id });
+  }
+  for (const startId of nodeIds) {
+    if (state.get(startId) !== 0) continue;
+    const stack = [{ id: startId, idx: 0 }];
+    state.set(startId, 1);
+    while (stack.length > 0) {
+      const top = stack[stack.length - 1];
+      const neighbors = adj.get(top.id) ?? [];
+      if (top.idx >= neighbors.length) {
+        state.set(top.id, 2);
+        stack.pop();
+        continue;
+      }
+      const { target, edgeId } = neighbors[top.idx++];
+      const tState = state.get(target);
+      if (tState === 1) {
+        backEdgeIds.add(edgeId);
+      } else if (tState === 0) {
+        state.set(target, 1);
+        stack.push({ id: target, idx: 0 });
+      }
     }
   }
-  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 type = node.data.elementType;
-        if (!BPMN_CONTAINER_TYPES.has(type)) return void 0;
-        const min = CONTAINER_MIN_SIZE[type];
-        const dir = type === "Pool" && poolsWithLanes.has(node.id) ? "DOWN" : "RIGHT";
-        return {
-          "elk.direction": dir,
-          "elk.nodeSize.constraints": "MINIMUM_SIZE",
-          ...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",
-        "elk.hierarchyHandling": "INCLUDE_CHILDREN",
-        "elk.edgeRouting": "ORTHOGONAL",
-        "elk.layered.spacing.nodeNodeBetweenLayers": "100",
-        "elk.layered.spacing.edgeNodeBetweenLayers": "40",
-        "elk.spacing.nodeNode": "60",
-        "elk.spacing.componentComponent": "80"
+  return backEdgeIds;
+}
+function extractSeqEdges(edges, nodeIds) {
+  return edges.filter((e) => {
+    const t = e.data?.edgeType ?? e.type;
+    return t === "sequenceFlow" && nodeIds.has(e.source) && nodeIds.has(e.target);
+  }).map((e) => ({ id: e.id, source: e.source, target: e.target, sourceHandle: e.sourceHandle ?? null }));
+}
+function topologicalSort(nodeIds, forwardEdges) {
+  const inDeg = new Map(nodeIds.map((id) => [id, 0]));
+  const adj = new Map(nodeIds.map((id) => [id, []]));
+  for (const e of forwardEdges) {
+    if (!inDeg.has(e.source) || !inDeg.has(e.target)) continue;
+    adj.get(e.source).push(e.target);
+    inDeg.set(e.target, (inDeg.get(e.target) ?? 0) + 1);
+  }
+  const queue = nodeIds.filter((id) => (inDeg.get(id) ?? 0) === 0);
+  const result = [];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    result.push(id);
+    for (const next of adj.get(id) ?? []) {
+      const d = (inDeg.get(next) ?? 1) - 1;
+      inDeg.set(next, d);
+      if (d === 0) queue.push(next);
+    }
+  }
+  const seen = new Set(result);
+  for (const id of nodeIds) {
+    if (!seen.has(id)) result.push(id);
+  }
+  return result;
+}
+function assignColumns(nodeIds, forwardEdges) {
+  const order = topologicalSort(nodeIds, forwardEdges);
+  const col = new Map(nodeIds.map((id) => [id, 0]));
+  const preds = new Map(nodeIds.map((id) => [id, []]));
+  for (const e of forwardEdges) {
+    preds.get(e.target)?.push(e.source);
+  }
+  for (const id of order) {
+    const predCols = (preds.get(id) ?? []).map((p) => col.get(p) ?? 0);
+    col.set(id, predCols.length > 0 ? Math.max(...predCols) + 1 : 0);
+  }
+  return col;
+}
+function detectGatewayPairs(nodes, forwardEdges) {
+  const pairs = /* @__PURE__ */ new Map();
+  const nodeIds = nodes.map((n) => n.id);
+  const succs = new Map(nodes.map((n) => [n.id, []]));
+  for (const e of forwardEdges) {
+    succs.get(e.source)?.push(e.target);
+  }
+  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
+  );
+  for (const split of splits) {
+    const branches = succs.get(split.id) ?? [];
+    if (branches.length < 2) continue;
+    const branchSets = branches.map((start) => {
+      const visited = /* @__PURE__ */ new Set();
+      const q = [start];
+      while (q.length) {
+        const curr = q.shift();
+        if (visited.has(curr)) continue;
+        visited.add(curr);
+        for (const next of succs.get(curr) ?? []) q.push(next);
+      }
+      return visited;
+    });
+    const common = [...branchSets[0]].filter(
+      (id) => branchSets.every((s) => s.has(id))
+    );
+    if (common.length === 0) continue;
+    const merge = common.reduce(
+      (a, b) => (topoPos.get(a) ?? Infinity) < (topoPos.get(b) ?? Infinity) ? a : b
+    );
+    pairs.set(split.id, merge);
+  }
+  return pairs;
+}
+function handleToRowBias(handle) {
+  if (!handle) return null;
+  if (handle.includes("top")) return -1;
+  if (handle.includes("bottom")) return 1;
+  if (handle.includes("right")) return 0;
+  return null;
+}
+function buildHandleMap(edges) {
+  const map = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (!map.has(e.source)) map.set(e.source, /* @__PURE__ */ new Map());
+    map.get(e.source).set(e.target, e.sourceHandle ?? null);
+  }
+  return map;
+}
+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, []]));
+  for (const e of forwardEdges) {
+    succs.get(e.source)?.push(e.target);
+  }
+  const handleMap = buildHandleMap(forwardEdges);
+  const sortedPairs = [...gatewayPairs.entries()].sort(
+    (a, b) => (columns.get(b[0]) ?? 0) - (columns.get(a[0]) ?? 0)
+  );
+  for (const [splitId, mergeId] of sortedPairs) {
+    const branches = succs.get(splitId) ?? [];
+    if (branches.length < 2) continue;
+    const splitRow = rows.get(splitId) ?? 0;
+    const getBranchNodes = (branchStart) => {
+      const result = [];
+      const visited = /* @__PURE__ */ new Set();
+      const q = [branchStart];
+      while (q.length) {
+        const curr = q.shift();
+        if (visited.has(curr) || curr === mergeId) continue;
+        visited.add(curr);
+        result.push(curr);
+        for (const next of succs.get(curr) ?? []) q.push(next);
       }
+      return result;
+    };
+    const splitHandles = handleMap.get(splitId);
+    const branchData = branches.map((start) => ({
+      start,
+      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++;
+    }
+    for (const b of branchData) {
+      const row = assigned.get(b.start) ?? splitRow;
+      for (const id of b.nodeIds) {
+        rows.set(id, row);
+      }
+    }
+  }
+  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
   );
-  const nodeMap = new Map(result.nodes.map((n) => [n.id, n]));
-  const edgeMap = new Map(result.edges.map((e) => [e.id, e]));
-  const updatedNodes = nodes.map((node) => {
-    const laid = nodeMap.get(node.id);
-    if (!laid) return node;
-    return { ...node, position: laid.position, width: laid.width, height: laid.height };
+  for (const split of unpairedSplits) {
+    const branches = succs.get(split.id) ?? [];
+    if (branches.length < 2) continue;
+    const splitRow = rows.get(split.id) ?? 0;
+    const getAllReachable = (start) => {
+      const result = [];
+      const visited = /* @__PURE__ */ new Set();
+      const q = [start];
+      while (q.length) {
+        const curr = q.shift();
+        if (visited.has(curr)) continue;
+        visited.add(curr);
+        result.push(curr);
+        for (const next of succs.get(curr) ?? []) q.push(next);
+      }
+      return result;
+    };
+    const splitHandles2 = handleMap.get(split.id);
+    const branchData = branches.map((start) => ({
+      start,
+      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++;
+    }
+    for (const b of branchData) {
+      const row = assigned2.get(b.start) ?? splitRow;
+      for (const id of b.nodeIds) rows.set(id, row);
+    }
+  }
+  return rows;
+}
+
+// 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 POOL_MIN_W = 720;
+var POOL_INNER_PAD = 8;
+function nW(node) {
+  return node.width ?? node.measured?.width ?? 120;
+}
+function nH(node) {
+  return node.height ?? node.measured?.height ?? 60;
+}
+function layoutPool(pool, lanes, content, allEdges) {
+  if (content.length === 0) {
+    if (lanes.length === 0) {
+      return { nodes: [], width: 240, height: 120 };
+    }
+    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,
+      height: h
+    };
+  }
+  const contentIds = new Set(content.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 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);
+    if (laneRows.length === 0) {
+      laneStats.set(laneId, { minRow: 0, maxRow: 0, rowCount: 1, height: LANE_MIN_H });
+    } 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 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) {
+    const c = columns.get(node.id) ?? 0;
+    colW.set(c, Math.max(colW.get(c) ?? 0, nW(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 innerW = LANE_LABEL_W + LANE_H_PAD + contentW + LANE_H_PAD;
+  const poolW = Math.max(POOL_MIN_W, innerW + POOL_INNER_PAD * 2);
+  const laneW = poolW - POOL_INNER_PAD * 2;
+  const laneY = /* @__PURE__ */ new Map();
+  let cumY = POOL_INNER_PAD;
+  for (let i = 0; i < laneIds.length; i++) {
+    const laneId = laneIds[i];
+    laneY.set(laneId, cumY);
+    cumY += laneStats.get(laneId)?.height ?? LANE_MIN_H;
+    if (i < laneIds.length - 1) cumY += POOL_INNER_PAD;
+  }
+  const poolH = cumY + POOL_INNER_PAD;
+  const positionedContent = content.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 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 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 } };
   });
-  const updatedEdges = edges.map((edge) => {
-    const laid = edgeMap.get(edge.id);
-    if (!laid) return edge;
-    const nextData = { ...edge.data };
-    if (laid.points && laid.points.length > 0) {
-      nextData.routingPoints = laid.points;
+  const NODE_MIN_GAP = 20;
+  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 currTop = curr.position.y;
+      const prevTop = prev.position.y;
+      const currBottom = curr.position.y + nH(curr);
+      const yOverlap = prevBottom + NODE_MIN_GAP > currTop && currBottom + NODE_MIN_GAP > prevTop;
+      if (!yOverlap) continue;
+      const prevRight = prev.position.x + nW(prev);
+      if (prevRight + NODE_MIN_GAP > curr.position.x) {
+        resolvedContent[laneNodeIndices[k].i] = {
+          ...curr,
+          position: {
+            x: prevRight + NODE_MIN_GAP,
+            y: curr.position.y
+          }
+        };
+      }
+    }
+  }
+  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],
+    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;
+  const node = byId.get(nodeId);
+  if (!node) return { x: 0, y: 0 };
+  const own = { ...node.position };
+  if (!node.parentId) {
+    cache.set(nodeId, own);
+    return own;
+  }
+  const parent = absolutePos(node.parentId, byId, cache);
+  const abs = { x: parent.x + own.x, y: parent.y + own.y };
+  cache.set(nodeId, abs);
+  return abs;
+}
+function laneOf(node, laneIds) {
+  return node.parentId && laneIds.has(node.parentId) ? node.parentId : void 0;
+}
+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);
+  return edges.map((edge) => {
+    const edgeType = edge.data?.edgeType ?? edge.type;
+    if (edgeType !== "sequenceFlow") {
+      const d = { ...edge.data };
+      delete d.routingPoints;
+      return { ...edge, data: d };
+    }
+    const src = byId.get(edge.source);
+    const tgt = byId.get(edge.target);
+    if (!src || !tgt) return edge;
+    const sAbs = abs(src.id);
+    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 d = { ...edge.data };
+      delete d.routingPoints;
+      return { ...edge, data: d };
+    }
+    let routingPoints;
+    if (backEdgeIds.has(edge.id)) {
+      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
+      ];
+    } 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
+        ];
+      } else {
+        routingPoints = [
+          { x: sCX, y: sCY },
+          { x: sharedX, y: sCY },
+          { x: sharedX, y: tCY },
+          { x: tCX, y: tCY }
+        ];
+      }
+    } else if (Math.abs(sCY - tCY) <= SAME_ROW_THRESHOLD) {
+      const d = { ...edge.data };
+      delete d.routingPoints;
+      return { ...edge, data: d };
     } else {
-      delete nextData.routingPoints;
+      const handle = edge.sourceHandle ?? "";
+      const exitsTop = handle.includes("top");
+      const exitsBottom = handle.includes("bottom");
+      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;
+        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: nextData };
+    return { ...edge, data: { ...edge.data, routingPoints } };
   });
-  return { nodes: updatedNodes, edges: updatedEdges };
+}
+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));
+  if (pools.length === 0) {
+    const { bpmnElkLayout: bpmnElkLayout2 } = await import('../elk-FSFIEL6O.js');
+    return bpmnElkLayout2(nodes, edges);
+  }
+  const poolIds = new Set(pools.map((p) => p.id));
+  const allLaneIds = new Set(lanes.map((l) => l.id));
+  const allContentIds = new Set(content.map((n) => n.id));
+  const allSeqEdges = edges.filter((e) => {
+    const t = e.data?.edgeType ?? e.type;
+    return t === "sequenceFlow" && allContentIds.has(e.source) && allContentIds.has(e.target);
+  }).map((e) => ({ id: e.id, source: e.source, target: e.target }));
+  const allBackEdgeIds = detectBackEdges([...allContentIds], allSeqEdges);
+  const poolPositionsDistinct = pools.some((p) => Math.abs(p.position.y) > 10);
+  const sortedPools = poolPositionsDistinct ? [...pools].sort((a, b) => a.position.y - b.position.y) : [...pools];
+  const resultNodes = [];
+  let stackY = 0;
+  for (const pool of sortedPools) {
+    const poolLanes = lanes.filter((l) => l.parentId === pool.id);
+    const laneIds = new Set(poolLanes.map((l) => l.id));
+    const poolContent = content.filter(
+      (n) => n.parentId === pool.id || n.parentId != null && laneIds.has(n.parentId)
+    );
+    const result = layoutPool(pool, poolLanes, poolContent, edges);
+    resultNodes.push({
+      ...pool,
+      position: { x: 0, y: stackY },
+      width: result.width,
+      height: result.height
+    });
+    for (const node of result.nodes) {
+      resultNodes.push(node);
+    }
+    stackY += result.height + POOL_V_GAP;
+  }
+  const layoutted = new Set(resultNodes.map((n) => n.id));
+  for (const node of nodes) {
+    if (!layoutted.has(node.id)) resultNodes.push(node);
+  }
+  const routedEdges = routeEdges(edges, resultNodes, allBackEdgeIds, allLaneIds, poolIds);
+  return { nodes: resultNodes, edges: routedEdges };
 }
 
 // src/layout/index.ts
@@ -102,6 +577,6 @@ function applyBpmnLayoutResult(state, result) {
   return applyLayoutResultToDiagram(state, result);
 }
 
-export { applyBpmnLayoutResult, bpmnDagreLayout, bpmnElkLayout };
+export { applyBpmnLayoutResult, bpmnCustomLayout, bpmnDagreLayout };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map