@aranzatech/diagrams-bpmn 0.2.14 → 0.3.0

package/dist/modeling/index.cjs

@@ -694,7 +694,9 @@ function createBpmnNode(options) {
     height: options.height ?? size.height,
     zIndex: getBpmnNodeZIndex(options.elementType),
     ...options.parentId ? { parentId: options.parentId } : {},
-    ...options.elementType === "Lane" && options.parentId ? { extent: "parent" } : {},
+    // extent:"parent" is intentionally omitted for Lane — it blocks resize beyond
+    // the Pool boundary before the Pool/Lane coupling can expand the Pool.
+    // Lane containment during drag is handled programmatically in handleNodeDragStop.
     ...dragHandle ? { dragHandle } : {}
   };
 }
@@ -711,12 +713,24 @@ function withBpmnNodeZIndexes(nodes) {
   });
 }
 var BPMN_POOL_LANE_LAYOUT = {
-  poolHeaderSize: 30,
-  laneHeaderSize: 24,
+  // Pool inner padding on all sides (no left label strip).
+  // 8px = pool border (2px) + 6px visible gap.
+  poolPad: 8,
+  /** @deprecated use poolPad */
+  poolHeaderSize: 8,
+  // Lane left label strip (vertical text).
+  laneHeaderSize: 28,
   laneGap: 0,
   verticalPoolHeaderSize: 28,
   minLaneSize: 96
 };
+var BPMN_POOL_LANE_STACK_LAYOUT = {
+  poolInnerPad: 8,
+  laneGap: 8,
+  minLaneWidth: 240,
+  minLaneHeight: 80,
+  defaultLaneHeight: 120
+};
 function getBpmnDragHandleSelector(elementType) {
   if (elementType === "Pool") return ".pool-drag-handle";
   if (elementType === "Lane") return ".lane-drag-handle";
@@ -787,7 +801,9 @@ function inferBpmnEdgeType(state, sourceId, targetId) {
   if (source.data.elementType === "Conversation" || source.data.elementType === "SubConversation" || source.data.elementType === "CallConversation" || target.data.elementType === "Conversation" || target.data.elementType === "SubConversation" || target.data.elementType === "CallConversation") {
     return "conversationLink";
   }
-  if (source.parentId && target.parentId && source.parentId !== target.parentId) {
+  const sourcePoolId = getAncestorContainerId(state, source, "Pool");
+  const targetPoolId = getAncestorContainerId(state, target, "Pool");
+  if (sourcePoolId && targetPoolId && sourcePoolId !== targetPoolId) {
     return "messageFlow";
   }
   return "sequenceFlow";
@@ -836,6 +852,67 @@ function getBpmnPoolLanes(state, poolId) {
     (node) => node.data.elementType === "Lane"
   );
 }
+function getBpmnNodeBounds(state, node) {
+  const position = getBpmnNodeAbsolutePosition(state, node) ?? node.position;
+  const size = getBpmnNodeSize(node);
+  return {
+    ...position,
+    width: size.width,
+    height: size.height
+  };
+}
+var BPMN_BOUNDARY_ATTACH_MARGIN = 32;
+function clampBoundaryCoordinate(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function isPointInsideExpandedBounds(point, origin, size) {
+  return point.x >= origin.x - BPMN_BOUNDARY_ATTACH_MARGIN && point.x <= origin.x + size.width + BPMN_BOUNDARY_ATTACH_MARGIN && point.y >= origin.y - BPMN_BOUNDARY_ATTACH_MARGIN && point.y <= origin.y + size.height + BPMN_BOUNDARY_ATTACH_MARGIN;
+}
+function snapBoundaryCenterToHostBorder(center, hostOrigin, hostSize) {
+  const distances = [
+    { side: "left", value: Math.abs(center.x - hostOrigin.x) },
+    { side: "right", value: Math.abs(center.x - (hostOrigin.x + hostSize.width)) },
+    { side: "top", value: Math.abs(center.y - hostOrigin.y) },
+    { side: "bottom", value: Math.abs(center.y - (hostOrigin.y + hostSize.height)) }
+  ].sort((a, b) => a.value - b.value);
+  const side = distances[0]?.side;
+  if (side === "left") {
+    return { x: hostOrigin.x, y: clampBoundaryCoordinate(center.y, hostOrigin.y, hostOrigin.y + hostSize.height) };
+  }
+  if (side === "right") {
+    return { x: hostOrigin.x + hostSize.width, y: clampBoundaryCoordinate(center.y, hostOrigin.y, hostOrigin.y + hostSize.height) };
+  }
+  if (side === "top") {
+    return { x: clampBoundaryCoordinate(center.x, hostOrigin.x, hostOrigin.x + hostSize.width), y: hostOrigin.y };
+  }
+  return {
+    x: clampBoundaryCoordinate(center.x, hostOrigin.x, hostOrigin.x + hostSize.width),
+    y: hostOrigin.y + hostSize.height
+  };
+}
+function findBpmnLaneAt(state, position) {
+  return state.nodes.find((node) => {
+    if (node.data.elementType !== "Lane") return false;
+    const bounds = getBpmnNodeBounds(state, node);
+    return position.x >= bounds.x && position.x <= bounds.x + bounds.width && position.y >= bounds.y && position.y <= bounds.y + bounds.height;
+  });
+}
+function getAncestorLaneId(state, node) {
+  let current = node;
+  while (current) {
+    if (current.data.elementType === "Lane") return current.id;
+    current = current.parentId ? diagramsCore.getNode(state, current.parentId) : void 0;
+  }
+  return void 0;
+}
+function getAncestorContainerId(state, node, elementType) {
+  let current = node;
+  while (current) {
+    if (current.data.elementType === elementType) return current.id;
+    current = current.parentId ? diagramsCore.getNode(state, current.parentId) : void 0;
+  }
+  return void 0;
+}
 function getNodeDimension(node, axis) {
   return node[axis] ?? node.measured?.[axis] ?? getBpmnElementSize(node.data.elementType)[axis];
 }
@@ -843,17 +920,250 @@ function getBpmnLaneOrderPosition(lane, orientation) {
   const size = getBpmnNodeSize(lane);
   return orientation === "vertical" ? lane.position.x + size.width / 2 : lane.position.y + size.height / 2;
 }
+function getBpmnPoolOrientation(pool) {
+  return pool.data.orientation === "vertical" ? "vertical" : "horizontal";
+}
+function getBpmnPoolLanesOrderedByStack(nodes, poolId, orientation) {
+  return nodes.filter((node) => node.parentId === poolId && node.data.elementType === "Lane").sort((a, b) => {
+    const aIndex = typeof a.data.laneIndex === "number" ? a.data.laneIndex : void 0;
+    const bIndex = typeof b.data.laneIndex === "number" ? b.data.laneIndex : void 0;
+    if (aIndex !== void 0 || bIndex !== void 0) return (aIndex ?? 0) - (bIndex ?? 0);
+    return orientation === "vertical" ? (a.position?.x ?? 0) - (b.position?.x ?? 0) : (a.position?.y ?? 0) - (b.position?.y ?? 0);
+  });
+}
+function layoutBpmnPoolLaneNodesPreservingHeights(nodes, poolId) {
+  const pool = nodes.find((node) => node.id === poolId && node.data.elementType === "Pool");
+  if (!pool) return nodes;
+  const orientation = getBpmnPoolOrientation(pool);
+  const lanes = getBpmnPoolLanesOrderedByStack(nodes, pool.id, orientation);
+  if (lanes.length === 0) return withBpmnNodeZIndexes(nodes);
+  const poolW = pool.measured?.width ?? pool.width ?? 720;
+  const poolH = pool.measured?.height ?? pool.height ?? 200;
+  const pad = BPMN_POOL_LANE_STACK_LAYOUT.poolInnerPad;
+  const gap = BPMN_POOL_LANE_STACK_LAYOUT.laneGap;
+  const minLaneW = BPMN_POOL_LANE_STACK_LAYOUT.minLaneWidth;
+  const minLaneH = BPMN_POOL_LANE_STACK_LAYOUT.minLaneHeight;
+  const defaultLaneH = BPMN_POOL_LANE_STACK_LAYOUT.defaultLaneHeight;
+  if (orientation === "vertical") {
+    const laneWidth2 = Math.max(
+      minLaneW,
+      Math.floor((poolW - pad * 2 - gap * Math.max(0, lanes.length - 1)) / Math.max(1, lanes.length))
+    );
+    const laneHeight = Math.max(minLaneH, poolH - pad * 2);
+    let cumX = pad;
+    const laneMap2 = new Map(
+      lanes.map((lane, index) => {
+        const nextLane = {
+          ...lane,
+          position: { x: cumX, y: pad },
+          width: laneWidth2,
+          height: laneHeight,
+          parentId: pool.id,
+          data: { ...lane.data, orientation: "vertical", laneIndex: index }
+        };
+        cumX += laneWidth2 + gap;
+        return [lane.id, nextLane];
+      })
+    );
+    const requiredPoolW = cumX - gap + pad;
+    return withBpmnNodeZIndexes(
+      nodes.map(
+        (node) => laneMap2.get(node.id) ?? (node.id === pool.id ? { ...pool, width: Math.max(requiredPoolW, poolW) } : node)
+      )
+    );
+  }
+  const laneWidth = Math.max(minLaneW, poolW - pad * 2);
+  let cumY = pad;
+  const laneMap = new Map(
+    lanes.map((lane, index) => {
+      const laneHeight = Math.max(minLaneH, lane.measured?.height ?? lane.height ?? defaultLaneH);
+      const nextLane = {
+        ...lane,
+        position: { x: pad, y: cumY },
+        width: laneWidth,
+        height: laneHeight,
+        parentId: pool.id,
+        data: { ...lane.data, orientation: "horizontal", laneIndex: index }
+      };
+      cumY += laneHeight + gap;
+      return [lane.id, nextLane];
+    })
+  );
+  const requiredPoolH = cumY - gap + pad;
+  return withBpmnNodeZIndexes(
+    nodes.map(
+      (node) => laneMap.get(node.id) ?? (node.id === pool.id ? { ...pool, height: Math.max(requiredPoolH, poolH) } : node)
+    )
+  );
+}
+function reorderBpmnPoolLaneAfterDropPreservingHeights(nodes, laneId) {
+  const lane = nodes.find((node) => node.id === laneId && node.data.elementType === "Lane");
+  if (!lane?.parentId) return nodes;
+  const pool = nodes.find((node) => node.id === lane.parentId && node.data.elementType === "Pool");
+  if (!pool) return nodes;
+  const orientation = getBpmnPoolOrientation(pool);
+  const lanes = getBpmnPoolLanesOrderedByStack(nodes, pool.id, orientation);
+  const moved = lanes.find((candidate) => candidate.id === lane.id);
+  if (!moved) return layoutBpmnPoolLaneNodesPreservingHeights(nodes, pool.id);
+  const withoutMoved = lanes.filter((candidate) => candidate.id !== lane.id);
+  const movedCenter = orientation === "vertical" ? (lane.position?.x ?? 0) + (lane.width ?? 0) / 2 : (lane.position?.y ?? 0) + (lane.height ?? 0) / 2;
+  const insertIndex = withoutMoved.findIndex((candidate) => {
+    const candidateCenter = orientation === "vertical" ? (candidate.position?.x ?? 0) + (candidate.width ?? 0) / 2 : (candidate.position?.y ?? 0) + (candidate.height ?? 0) / 2;
+    return movedCenter < candidateCenter;
+  });
+  const ordered = [...withoutMoved];
+  ordered.splice(insertIndex === -1 ? ordered.length : insertIndex, 0, moved);
+  const orderedMap = new Map(ordered.map((candidate, index) => [candidate.id, index]));
+  return layoutBpmnPoolLaneNodesPreservingHeights(
+    nodes.map(
+      (node) => node.parentId === pool.id && node.data.elementType === "Lane" ? { ...node, data: { ...node.data, laneIndex: orderedMap.get(node.id) ?? 0 } } : node
+    ),
+    pool.id
+  );
+}
+function getAppendedBpmnLaneFrame(nodes, poolOrId) {
+  const pool = typeof poolOrId === "string" ? nodes.find((node) => node.id === poolOrId && node.data.elementType === "Pool") : poolOrId;
+  if (!pool || pool.data.elementType !== "Pool") return null;
+  const orientation = getBpmnPoolOrientation(pool);
+  const existingLanes = getBpmnPoolLanesOrderedByStack(nodes, pool.id, orientation);
+  const poolW = pool.measured?.width ?? pool.width ?? 600;
+  const poolH = pool.measured?.height ?? pool.height ?? 400;
+  const pad = BPMN_POOL_LANE_STACK_LAYOUT.poolInnerPad;
+  const gap = BPMN_POOL_LANE_STACK_LAYOUT.laneGap;
+  const minLaneW = BPMN_POOL_LANE_STACK_LAYOUT.minLaneWidth;
+  const minLaneH = BPMN_POOL_LANE_STACK_LAYOUT.minLaneHeight;
+  const defaultLaneH = BPMN_POOL_LANE_STACK_LAYOUT.defaultLaneHeight;
+  if (orientation === "horizontal") {
+    const lastLane2 = existingLanes[existingLanes.length - 1];
+    return {
+      position: {
+        x: pad,
+        y: lastLane2 ? (lastLane2.position?.y ?? pad) + (lastLane2.height ?? defaultLaneH) + gap : pad
+      },
+      width: Math.max(minLaneW, poolW - pad * 2),
+      height: existingLanes.length === 0 ? Math.max(minLaneH, poolH - pad * 2) : defaultLaneH,
+      laneIndex: existingLanes.length,
+      orientation
+    };
+  }
+  const lastLane = existingLanes[existingLanes.length - 1];
+  return {
+    position: {
+      x: lastLane ? (lastLane.position?.x ?? pad) + (lastLane.width ?? defaultLaneH) + gap : pad,
+      y: pad
+    },
+    width: existingLanes.length === 0 ? Math.max(minLaneW, poolW - pad * 2) : defaultLaneH,
+    height: Math.max(minLaneH, poolH - pad * 2),
+    laneIndex: existingLanes.length,
+    orientation
+  };
+}
+function getBpmnPoolLaneNodeMaxSize(state, nodeId) {
+  const n = diagramsCore.getNode(state, nodeId);
+  if (n?.data.elementType === "Lane" && n.parentId) {
+    const pool = diagramsCore.getNode(state, n.parentId);
+    if (pool) {
+      const siblings = state.nodes.filter(
+        (x) => x.parentId === n.parentId && x.data.elementType === "Lane" && x.id !== n.id
+      );
+      const poolH = pool.measured?.height ?? pool.height ?? 500;
+      const siblingsMinH = siblings.length * BPMN_POOL_LANE_STACK_LAYOUT.minLaneHeight;
+      const siblingGaps = siblings.length * BPMN_POOL_LANE_STACK_LAYOUT.laneGap;
+      const maxH = Math.max(
+        BPMN_POOL_LANE_STACK_LAYOUT.minLaneHeight,
+        poolH - BPMN_POOL_LANE_STACK_LAYOUT.poolInnerPad * 2 - siblingsMinH - siblingGaps
+      );
+      return {
+        width: (pool.width ?? 720) - BPMN_POOL_LANE_STACK_LAYOUT.poolInnerPad * 2,
+        height: maxH
+      };
+    }
+  }
+  return void 0;
+}
+function getBpmnPoolLaneNodeMinSize(state, nodeId) {
+  const n = diagramsCore.getNode(state, nodeId);
+  if (n?.data.elementType === "Pool") {
+    const lanes = state.nodes.filter((x) => x.parentId === nodeId && x.data.elementType === "Lane");
+    if (lanes.length > 0) {
+      const minW = Math.max(...lanes.map((l) => (l.width ?? 0) + BPMN_POOL_LANE_STACK_LAYOUT.poolInnerPad * 2));
+      const minH = lanes.reduce((s, l) => s + (l.height ?? BPMN_POOL_LANE_STACK_LAYOUT.defaultLaneHeight), 0) + BPMN_POOL_LANE_STACK_LAYOUT.poolInnerPad * 2 + Math.max(0, lanes.length - 1) * BPMN_POOL_LANE_STACK_LAYOUT.laneGap;
+      return { width: minW, height: minH };
+    }
+  }
+  return void 0;
+}
+function applyBpmnPoolLaneDimensionChange(nodes, previousNodes, nodeId, width, height) {
+  const node = nodes.find((candidate) => candidate.id === nodeId);
+  const previousNode = previousNodes.find((candidate) => candidate.id === nodeId);
+  if (!node) return nodes;
+  const curW = previousNode?.measured?.width ?? previousNode?.width ?? 0;
+  const curH = previousNode?.measured?.height ?? previousNode?.height ?? 0;
+  if (Math.abs(width - curW) < 1 && Math.abs(height - curH) < 1) return nodes;
+  const pad = BPMN_POOL_LANE_STACK_LAYOUT.poolInnerPad;
+  const gap = BPMN_POOL_LANE_STACK_LAYOUT.laneGap;
+  const minLaneW = BPMN_POOL_LANE_STACK_LAYOUT.minLaneWidth;
+  const defaultLaneH = BPMN_POOL_LANE_STACK_LAYOUT.defaultLaneHeight;
+  if (node.data.elementType === "Pool") {
+    const targetLaneW = Math.max(minLaneW, width - pad * 2);
+    return nodes.map(
+      (candidate) => candidate.parentId === node.id && candidate.data.elementType === "Lane" ? {
+        ...candidate,
+        width: targetLaneW,
+        measured: {
+          width: targetLaneW,
+          height: candidate.measured?.height ?? candidate.height ?? defaultLaneH
+        },
+        position: { x: pad, y: candidate.position?.y ?? pad }
+      } : candidate
+    );
+  }
+  if (node.data.elementType === "Lane" && node.parentId) {
+    const pool = nodes.find((candidate) => candidate.id === node.parentId && candidate.data.elementType === "Pool");
+    if (!pool) return nodes;
+    const poolW = Math.max(width + pad * 2, pool.measured?.width ?? pool.width ?? 720);
+    const sortedLanes = getBpmnPoolLanesOrderedByStack(nodes, node.parentId, "horizontal");
+    let cumY = pad;
+    const laneMap = /* @__PURE__ */ new Map();
+    for (const lane of sortedLanes) {
+      const laneH = lane.id === node.id ? height : lane.measured?.height ?? lane.height ?? defaultLaneH;
+      laneMap.set(lane.id, {
+        ...lane,
+        width,
+        height: laneH,
+        measured: { width, height: laneH },
+        position: { x: pad, y: cumY }
+      });
+      cumY += laneH + gap;
+    }
+    const newPoolH = cumY - gap + pad;
+    return nodes.map((candidate) => {
+      if (candidate.id === pool.id) {
+        return {
+          ...candidate,
+          width: poolW,
+          height: newPoolH,
+          measured: { width: poolW, height: newPoolH }
+        };
+      }
+      return laneMap.get(candidate.id) ?? candidate;
+    });
+  }
+  return nodes;
+}
 function resizeHorizontalBpmnLanes(lanes, pool) {
+  const pad = BPMN_POOL_LANE_LAYOUT.poolPad;
   const poolSize = getBpmnNodeSize(pool);
-  const laneWidth = Math.max(BPMN_POOL_LANE_LAYOUT.minLaneSize, poolSize.width - BPMN_POOL_LANE_LAYOUT.poolHeaderSize);
-  const laneHeight = Math.max(BPMN_POOL_LANE_LAYOUT.minLaneSize, poolSize.height / Math.max(1, lanes.length));
+  const laneWidth = Math.max(BPMN_POOL_LANE_LAYOUT.minLaneSize, poolSize.width - pad * 2);
+  const availH = Math.max(0, poolSize.height - pad * 2);
+  const laneHeight = Math.max(BPMN_POOL_LANE_LAYOUT.minLaneSize, availH / Math.max(1, lanes.length));
   return lanes.map((lane, index) => ({
     ...lane,
-    position: { x: BPMN_POOL_LANE_LAYOUT.poolHeaderSize, y: index * laneHeight },
+    position: { x: pad, y: pad + index * laneHeight },
     width: laneWidth,
     height: laneHeight,
     parentId: pool.id,
-    extent: "parent",
+    // extent:"parent" intentionally omitted — blocks resize→Pool coupling.
     zIndex: getBpmnNodeZIndex("Lane"),
     data: { ...lane.data, orientation: "horizontal", laneIndex: index }
   }));
@@ -884,10 +1194,22 @@ function layoutBpmnPoolLaneNodes(nodes, poolId) {
     return getBpmnLaneOrderPosition(a, orientation) - getBpmnLaneOrderPosition(b, orientation);
   });
   if (lanes.length === 0) return withBpmnNodeZIndexes(nodes);
-  const laneMap = new Map(
-    (orientation === "vertical" ? resizeVerticalBpmnLanes(lanes, pool) : resizeHorizontalBpmnLanes(lanes, pool)).map((lane) => [lane.id, lane])
+  const resizedLanes = orientation === "vertical" ? resizeVerticalBpmnLanes(lanes, pool) : resizeHorizontalBpmnLanes(lanes, pool);
+  const laneMap = new Map(resizedLanes.map((lane) => [lane.id, lane]));
+  const pad = BPMN_POOL_LANE_LAYOUT.poolPad;
+  const totalLaneH = resizedLanes.reduce((sum, l) => sum + (l.height ?? 0), 0);
+  const requiredPoolH = totalLaneH + pad * 2;
+  const poolMap = /* @__PURE__ */ new Map();
+  if (orientation === "horizontal") {
+    const currentH = getBpmnNodeSize(pool).height;
+    poolMap.set(pool.id, {
+      ...pool,
+      height: Math.max(requiredPoolH, currentH)
+    });
+  }
+  return withBpmnNodeZIndexes(
+    nodes.map((node) => laneMap.get(node.id) ?? poolMap.get(node.id) ?? node)
   );
-  return withBpmnNodeZIndexes(nodes.map((node) => laneMap.get(node.id) ?? node));
 }
 function reorderBpmnLaneAfterDrop(nodes, laneId) {
   const lane = nodes.find((node) => node.id === laneId && node.data.elementType === "Lane");
@@ -946,9 +1268,116 @@ function findBpmnContainerAt(state, options) {
     }
   });
 }
+function resolveBpmnDropTarget(state, options) {
+  if (options.elementType === "Pool") {
+    return { highlightedContainerId: null, invalidContainerId: null, isValid: true };
+  }
+  if (options.elementType === "Lane") {
+    const pool = state.nodes.find((node) => {
+      if (node.data.elementType !== "Pool") return false;
+      const bounds = getBpmnNodeBounds(state, node);
+      return options.position.x >= bounds.x && options.position.x <= bounds.x + bounds.width && options.position.y >= bounds.y && options.position.y <= bounds.y + bounds.height;
+    });
+    return {
+      ...pool ? { container: pool } : {},
+      highlightedContainerId: pool?.id ?? null,
+      invalidContainerId: null,
+      isValid: Boolean(pool)
+    };
+  }
+  const lane = findBpmnLaneAt(state, options.position);
+  if (lane) {
+    return {
+      container: lane,
+      highlightedContainerId: lane.id,
+      invalidContainerId: null,
+      isValid: true
+    };
+  }
+  const container = findBpmnContainerAt(state, {
+    position: options.position,
+    ...options.excludeId ? { excludeId: options.excludeId } : {}
+  });
+  if (container?.data.elementType === "Pool") {
+    const hasLanes = getBpmnPoolLanes(state, container.id).length > 0;
+    if (hasLanes) {
+      return {
+        highlightedContainerId: null,
+        invalidContainerId: container.id,
+        isValid: false
+      };
+    }
+  }
+  return {
+    ...container ? { container } : {},
+    highlightedContainerId: getAncestorLaneId(state, container) ?? container?.id ?? null,
+    invalidContainerId: null,
+    isValid: true
+  };
+}
 function getBpmnNodeCenter(node, absolutePosition) {
   return diagramsCore.getNodeCenterPosition(absolutePosition, getBpmnNodeSize(node));
 }
+function getBoundaryEventAttachment(state, boundaryNode) {
+  if (boundaryNode.data.elementType !== "BoundaryEvent") return null;
+  const boundaryOrigin = getBpmnNodeAbsolutePosition(state, boundaryNode) ?? boundaryNode.position;
+  const boundarySize = getBpmnNodeSize(boundaryNode);
+  const boundaryCenter = {
+    x: boundaryOrigin.x + boundarySize.width / 2,
+    y: boundaryOrigin.y + boundarySize.height / 2
+  };
+  const candidates = state.nodes.filter((node) => node.id !== boundaryNode.id && acceptsBoundaryEvents(node.data.elementType)).map((node) => {
+    const origin = getBpmnNodeAbsolutePosition(state, node) ?? node.position;
+    const size = getBpmnNodeSize(node);
+    const hostCenter = { x: origin.x + size.width / 2, y: origin.y + size.height / 2 };
+    return {
+      node,
+      origin,
+      size,
+      distance: Math.hypot(boundaryCenter.x - hostCenter.x, boundaryCenter.y - hostCenter.y)
+    };
+  }).filter(({ origin, size }) => isPointInsideExpandedBounds(boundaryCenter, origin, size)).sort((a, b) => a.distance - b.distance);
+  const host = candidates[0];
+  if (!host) return null;
+  const snappedCenter = snapBoundaryCenterToHostBorder(boundaryCenter, host.origin, host.size);
+  return {
+    hostId: host.node.id,
+    position: {
+      x: snappedCenter.x - host.origin.x - boundarySize.width / 2,
+      y: snappedCenter.y - host.origin.y - boundarySize.height / 2
+    }
+  };
+}
+function getBpmnEdgeLaneContext(state, edgeOrId) {
+  const edge = typeof edgeOrId === "string" ? state.edges.find((candidate) => candidate.id === edgeOrId) : edgeOrId;
+  if (!edge) return void 0;
+  const source = diagramsCore.getNode(state, edge.source);
+  const target = diagramsCore.getNode(state, edge.target);
+  if (!source || !target) return void 0;
+  const sourceLaneId = getAncestorLaneId(state, source);
+  const targetLaneId = getAncestorLaneId(state, target);
+  const sourcePoolId = getAncestorContainerId(state, source, "Pool");
+  const targetPoolId = getAncestorContainerId(state, target, "Pool");
+  const sameLane = Boolean(sourceLaneId) && sourceLaneId === targetLaneId;
+  const samePool = Boolean(sourcePoolId) && sourcePoolId === targetPoolId;
+  const crossesLanesWithinPool = Boolean(
+    sourceLaneId && targetLaneId && sourceLaneId !== targetLaneId && samePool
+  );
+  const crossesPools = Boolean(
+    sourcePoolId && targetPoolId && sourcePoolId !== targetPoolId
+  );
+  return {
+    edgeId: edge.id,
+    ...sourceLaneId ? { sourceLaneId } : {},
+    ...targetLaneId ? { targetLaneId } : {},
+    ...sourcePoolId ? { sourcePoolId } : {},
+    ...targetPoolId ? { targetPoolId } : {},
+    sameLane,
+    samePool,
+    crossesLanesWithinPool,
+    crossesPools
+  };
+}
 function resolvePoolLaneDirection(pool) {
   return pool.data.orientation === "vertical" ? "horizontal" : "vertical";
 }
@@ -1038,6 +1467,14 @@ function validateBpmnConnectionForEdgeType(state, edgeType, source, target) {
   }
   return true;
 }
+function resolveBpmnConnection(state, sourceId, targetId, requestedType) {
+  const source = diagramsCore.getNode(state, sourceId);
+  const target = diagramsCore.getNode(state, targetId);
+  if (!source || !target) return { ok: false, reason: "No se encontr\xF3 el origen o destino." };
+  const validation = validateBpmnConnectionForEdgeType(state, requestedType, source, target);
+  if (validation !== true) return { ok: false, reason: validation };
+  return { ok: true, edgeType: requestedType };
+}
 function validateEdgeCardinality(state, edgeType, source, target) {
   if (edgeType !== "sequenceFlow") return true;
   const sourceMax = BPMN_ELEMENT_CATALOG[source.data.elementType].maxOutgoing;
@@ -1225,6 +1662,28 @@ function reparentBpmnNodeAtPosition(state, options) {
   });
 }
 var BE_HALF = 18;
+function getBoundarySpanRatio(value, size) {
+  const min = BE_HALF;
+  const max = size - BE_HALF;
+  if (max <= min) return 0.5;
+  return (clampBoundaryCoordinate(value, min, max) - min) / (max - min);
+}
+function fromBoundarySpanRatio(ratio, size) {
+  const min = BE_HALF;
+  const max = size - BE_HALF;
+  if (max <= min) return size / 2;
+  return min + (max - min) * ratio;
+}
+function detectBoundarySide(center, hostSize) {
+  const distances = [
+    { side: "left", value: Math.abs(center.x) },
+    { side: "right", value: Math.abs(center.x - hostSize.width) },
+    { side: "top", value: Math.abs(center.y) },
+    { side: "bottom", value: Math.abs(center.y - hostSize.height) }
+  ];
+  distances.sort((a, b) => a.value - b.value);
+  return distances[0]?.side ?? "bottom";
+}
 function clampBoundaryEventsAfterResize(state, hostId, oldW, oldH, newW, newH) {
   const boundaryEvents = state.nodes.filter(
     (n) => n.data.elementType === "BoundaryEvent" && n.parentId === hostId
@@ -1235,25 +1694,21 @@ function clampBoundaryEventsAfterResize(state, hostId, oldW, oldH, newW, newH) {
     const py = be.position?.y ?? 0;
     const cx = px + BE_HALF;
     const cy = py + BE_HALF;
-    const distLeft = Math.abs(cx);
-    const distRight = Math.abs(cx - oldW);
-    const distTop = Math.abs(cy);
-    const distBottom = Math.abs(cy - oldH);
-    const minDist = Math.min(distLeft, distRight, distTop, distBottom);
+    const side = detectBoundarySide({ x: cx, y: cy }, { width: oldW, height: oldH });
     let newCx;
     let newCy;
-    if (minDist === distBottom) {
+    if (side === "bottom") {
       newCy = newH;
-      newCx = Math.min(Math.max(cx, BE_HALF), newW - BE_HALF);
-    } else if (minDist === distRight) {
+      newCx = fromBoundarySpanRatio(getBoundarySpanRatio(cx, oldW), newW);
+    } else if (side === "right") {
       newCx = newW;
-      newCy = Math.min(Math.max(cy, BE_HALF), newH - BE_HALF);
-    } else if (minDist === distTop) {
+      newCy = fromBoundarySpanRatio(getBoundarySpanRatio(cy, oldH), newH);
+    } else if (side === "top") {
       newCy = 0;
-      newCx = Math.min(Math.max(cx, BE_HALF), newW - BE_HALF);
+      newCx = fromBoundarySpanRatio(getBoundarySpanRatio(cx, oldW), newW);
     } else {
       newCx = 0;
-      newCy = Math.min(Math.max(cy, BE_HALF), newH - BE_HALF);
+      newCy = fromBoundarySpanRatio(getBoundarySpanRatio(cy, oldH), newH);
     }
     next = diagramsCore.moveNode(next, be.id, { x: newCx - BE_HALF, y: newCy - BE_HALF });
   }
@@ -1520,8 +1975,10 @@ function withBpmnLayoutCache(layoutFn, cache) {
 exports.BPMN_EDGE_CONNECTION_RULES = BPMN_EDGE_CONNECTION_RULES;
 exports.BPMN_MODELING_RULES = BPMN_MODELING_RULES;
 exports.BPMN_POOL_LANE_LAYOUT = BPMN_POOL_LANE_LAYOUT;
+exports.BPMN_POOL_LANE_STACK_LAYOUT = BPMN_POOL_LANE_STACK_LAYOUT;
 exports.BPMN_ROUTABLE_EDGE_TYPES = BPMN_ROUTABLE_EDGE_TYPES;
 exports.BPMN_SELECTION_STYLE = BPMN_SELECTION_STYLE;
+exports.applyBpmnPoolLaneDimensionChange = applyBpmnPoolLaneDimensionChange;
 exports.attachBoundaryEventCommand = attachBoundaryEventCommand;
 exports.bpmnConnectionValidators = bpmnConnectionValidators;
 exports.canContainBpmnElement = canContainBpmnElement;
@@ -1537,15 +1994,21 @@ exports.deleteBpmnElementsCommand = deleteBpmnElementsCommand;
 exports.deserializeBpmnDiagram = deserializeBpmnDiagram;
 exports.deserializeBpmnDiagramSnapshot = deserializeBpmnDiagramSnapshot;
 exports.findBpmnContainerAt = findBpmnContainerAt;
+exports.getAppendedBpmnLaneFrame = getAppendedBpmnLaneFrame;
+exports.getBoundaryEventAttachment = getBoundaryEventAttachment;
 exports.getBpmnDragHandleSelector = getBpmnDragHandleSelector;
 exports.getBpmnEdgeLabelLayout = getBpmnEdgeLabelLayout;
+exports.getBpmnEdgeLaneContext = getBpmnEdgeLaneContext;
 exports.getBpmnElementSize = getBpmnElementSize;
 exports.getBpmnLaneIndexAtPosition = getBpmnLaneIndexAtPosition;
 exports.getBpmnNodeAbsolutePosition = getBpmnNodeAbsolutePosition;
 exports.getBpmnNodeCenter = getBpmnNodeCenter;
 exports.getBpmnNodeSize = getBpmnNodeSize;
 exports.getBpmnNodeZIndex = getBpmnNodeZIndex;
+exports.getBpmnPoolLaneNodeMaxSize = getBpmnPoolLaneNodeMaxSize;
+exports.getBpmnPoolLaneNodeMinSize = getBpmnPoolLaneNodeMinSize;
 exports.getBpmnPoolLanes = getBpmnPoolLanes;
+exports.getBpmnPoolOrientation = getBpmnPoolOrientation;
 exports.getBpmnTabOrder = getBpmnTabOrder;
 exports.groupAsBpmnSubProcessCommand = groupAsBpmnSubProcessCommand;
 exports.inferBpmnEdgeType = inferBpmnEdgeType;
@@ -1554,6 +2017,7 @@ exports.isBpmnEdgeRoutingEditable = isBpmnEdgeRoutingEditable;
 exports.isBpmnElementResizable = isBpmnElementResizable;
 exports.isBpmnProcessNode = isBpmnProcessNode;
 exports.layoutBpmnPoolLaneNodes = layoutBpmnPoolLaneNodes;
+exports.layoutBpmnPoolLaneNodesPreservingHeights = layoutBpmnPoolLaneNodesPreservingHeights;
 exports.layoutBpmnPoolLanes = layoutBpmnPoolLanes;
 exports.moveBpmnLaneCommand = moveBpmnLaneCommand;
 exports.parseBpmnDiagramDocument = parseBpmnDiagramDocument;
@@ -1562,11 +2026,14 @@ exports.persistBpmnHistory = persistBpmnHistory;
 exports.reorderBpmnLane = reorderBpmnLane;
 exports.reorderBpmnLaneAfterDrop = reorderBpmnLaneAfterDrop;
 exports.reorderBpmnLaneCommand = reorderBpmnLaneCommand;
+exports.reorderBpmnPoolLaneAfterDropPreservingHeights = reorderBpmnPoolLaneAfterDropPreservingHeights;
 exports.reparentBpmnNodeAtPosition = reparentBpmnNodeAtPosition;
 exports.reparentBpmnNodeCommand = reparentBpmnNodeCommand;
 exports.replaceBpmnNodeCommand = replaceBpmnNodeCommand;
 exports.resizeBpmnNodeByHandleCommand = resizeBpmnNodeByHandleCommand;
 exports.resizeBpmnNodeCommand = resizeBpmnNodeCommand;
+exports.resolveBpmnConnection = resolveBpmnConnection;
+exports.resolveBpmnDropTarget = resolveBpmnDropTarget;
 exports.restoreBpmnHistory = restoreBpmnHistory;
 exports.routeBpmnEdgeCommand = routeBpmnEdgeCommand;
 exports.runBpmnCommand = runBpmnCommand;