bpmn-js 18.22.0 → 18.23.0

package/dist/bpmn-modeler.development.js

@@ -1,5 +1,5 @@
 /*!
- * bpmn-js - bpmn-modeler v18.22.0
+ * bpmn-js - bpmn-modeler v18.23.0
  *
  * Copyright (c) 2014-present, camunda Services GmbH
  *
@@ -8,7 +8,7 @@
  *
  * Source Code: https://github.com/bpmn-io/bpmn-js
  *
- * Date: 2026-07-23
+ * Date: 2026-08-10
  */
 (function (global, factory) {
 	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
@@ -4544,6 +4544,17 @@
 	  return isObject(value) && has(value, 'labelTarget');
 	}
 
+	/**
+	 * Checks whether a value is an instance of Root.
+	 *
+	 * @param {any} value
+	 *
+	 * @return {boolean}
+	 */
+	function isRoot(value) {
+	  return isObject(value) && isNil(value.parent);
+	}
+
 	/**
 	 * @typedef {import('../core/Types.js').ElementLike} Element
 	 * @typedef {import('../core/Types.js').ConnectionLike} Connection
@@ -17087,6 +17098,23 @@
 	 * @see http://bpmn.io/license for more information.
 	 */
 
+	/**
+	 * Padding added around the diagram bounds on SVG export.
+	 *
+	 * `getBBox` returns the geometry bounds only, excluding element strokes, so
+	 * without padding strokes at the diagram edges get clipped. Historically this
+	 * padding was provided implicitly by element outlines, which diagram-js now
+	 * creates lazily (diagram-js@15.19, bpmn-io/diagram-js#1064).
+	 */
+	const EXPORT_PADDING = 5;
+
+	/**
+	 * Class set on the canvas container to hide element outlines, which diagram-js
+	 * excludes from rendering while present. Applied when measuring the export
+	 * bounds so lazily created outlines do not skew them.
+	 */
+	const OUTLINE_HIDDEN_CLS = 'djs-outline-hidden';
+
 	/**
 	 * @template T
 	 *
@@ -17537,15 +17565,31 @@
 	    const contents = innerSVG(contentNode),
 	          defs = defsNode ? '<defs>' + innerSVG(defsNode) + '</defs>' : '';
 
-	    const bbox = contentNode.getBBox();
+	    // hide outlines so they do not skew the measured bounds
+	    const container = canvas.getContainer();
+
+	    classes$1(container).add(OUTLINE_HIDDEN_CLS);
+
+	    let bbox;
+
+	    try {
+	      bbox = contentNode.getBBox();
+	    } finally {
+	      classes$1(container).remove(OUTLINE_HIDDEN_CLS);
+	    }
+
+	    const x = bbox.x - EXPORT_PADDING,
+	          y = bbox.y - EXPORT_PADDING,
+	          width = bbox.width + EXPORT_PADDING * 2,
+	          height = bbox.height + EXPORT_PADDING * 2;
 
 	    svg =
 	      '<?xml version="1.0" encoding="utf-8"?>\n' +
 	      '<!-- created with bpmn-js / http://bpmn.io -->\n' +
 	      '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">\n' +
 	      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" ' +
-	      'width="' + bbox.width + '" height="' + bbox.height + '" ' +
-	      'viewBox="' + bbox.x + ' ' + bbox.y + ' ' + bbox.width + ' ' + bbox.height + '" version="1.1">' +
+	      'width="' + width + '" height="' + height + '" ' +
+	      'viewBox="' + x + ' ' + y + ' ' + width + ' ' + height + '" version="1.1">' +
 	      defs + contents +
 	      '</svg>';
 	  } catch (e) {
@@ -22527,7 +22571,7 @@
 	// document wide unique overlay ids
 	var ids$2 = new IdGenerator('ov');
 
-	var LOW_PRIORITY$q = 500;
+	var LOW_PRIORITY$s = 500;
 
 	/**
 	 * @typedef {import('../../core/Canvas.js').default} Canvas
@@ -23157,7 +23201,7 @@
 
 	  // move integration
 
-	  eventBus.on('element.changed', LOW_PRIORITY$q, function(e) {
+	  eventBus.on('element.changed', LOW_PRIORITY$s, function(e) {
 	    var element = e.element;
 
 	    var container = self._getOverlayContainer(element, true);
@@ -24239,7 +24283,7 @@
 	 * @typedef {import('../../model/Types').Shape} Shape
 	 */
 
-	var LOW_PRIORITY$p = 250;
+	var LOW_PRIORITY$r = 250;
 	var ARROW_DOWN_SVG = '<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 16 16"><path fill-rule="evenodd" d="M4.81801948,3.50735931 L10.4996894,9.1896894 L10.5,4 L12,4 L12,12 L4,12 L4,10.5 L9.6896894,10.4996894 L3.75735931,4.56801948 C3.46446609,4.27512627 3.46446609,3.80025253 3.75735931,3.50735931 C4.05025253,3.21446609 4.52512627,3.21446609 4.81801948,3.50735931 Z"/></svg>';
 
 	var EMPTY_MARKER = 'bjs-drilldown-empty';
@@ -24264,7 +24308,7 @@
 
 	  var self = this;
 
-	  this.executed('shape.toggleCollapse', LOW_PRIORITY$p, function(context) {
+	  this.executed('shape.toggleCollapse', LOW_PRIORITY$r, function(context) {
 	    var shape = context.shape;
 
 	    // Add overlay to the collapsed shape
@@ -24276,7 +24320,7 @@
 	  }, true);
 
 
-	  this.reverted('shape.toggleCollapse', LOW_PRIORITY$p, function(context) {
+	  this.reverted('shape.toggleCollapse', LOW_PRIORITY$r, function(context) {
 	    var shape = context.shape;
 
 	    // Add overlay to the collapsed shape
@@ -24288,7 +24332,7 @@
 	  }, true);
 
 
-	  this.executed([ 'shape.create', 'shape.move', 'shape.delete' ], LOW_PRIORITY$p,
+	  this.executed([ 'shape.create', 'shape.move', 'shape.delete' ], LOW_PRIORITY$r,
 	    function(context) {
 	      var oldParent = context.oldParent,
 	          newParent = context.newParent || context.parent,
@@ -24305,7 +24349,7 @@
 	    }, true);
 
 
-	  this.reverted([ 'shape.create', 'shape.move', 'shape.delete' ], LOW_PRIORITY$p,
+	  this.reverted([ 'shape.create', 'shape.move', 'shape.delete' ], LOW_PRIORITY$r,
 	    function(context) {
 	      var oldParent = context.oldParent,
 	          newParent = context.newParent || context.parent,
@@ -24582,7 +24626,7 @@
 	  return isPrimaryButton(event) || isAuxiliaryButton(event);
 	}
 
-	var LOW_PRIORITY$o = 500;
+	var LOW_PRIORITY$q = 500;
 
 
 	/**
@@ -24779,7 +24823,7 @@
 	  eventBus.on([
 	    'shape.changed',
 	    'connection.changed'
-	  ], LOW_PRIORITY$o, function(event) {
+	  ], LOW_PRIORITY$q, function(event) {
 
 	    var element = event.element,
 	        gfx = event.gfx;
@@ -24787,7 +24831,7 @@
 	    eventBus.fire('interactionEvents.updateHit', { element: element, gfx: gfx });
 	  });
 
-	  eventBus.on('interactionEvents.createHit', LOW_PRIORITY$o, function(event) {
+	  eventBus.on('interactionEvents.createHit', LOW_PRIORITY$q, function(event) {
 	    var element = event.element,
 	        gfx = event.gfx;
 
@@ -25750,7 +25794,7 @@
 	Keyboard.prototype.isShift = isShift;
 	Keyboard.prototype.isKey = isKey;
 
-	var LOW_PRIORITY$n = 500;
+	var LOW_PRIORITY$p = 500;
 
 
 	/**
@@ -25766,7 +25810,7 @@
 
 	  var self = this;
 
-	  eventBus.on('editorActions.init', LOW_PRIORITY$n, function(event) {
+	  eventBus.on('editorActions.init', LOW_PRIORITY$p, function(event) {
 
 	    var editorActions = event.editorActions;
 
@@ -29760,7 +29804,7 @@
 	 * @typedef {import('diagram-js/lib/features/context-pad/ContextPadProvider').default<Element>} ContextPadProvider
 	 */
 
-	var LOW_PRIORITY$m = 900;
+	var LOW_PRIORITY$o = 900;
 
 	/**
 	 * A provider for the `Align elements` context pad entry.
@@ -29774,7 +29818,7 @@
 	 */
 	function AlignElementsContextPadProvider(contextPad, popupMenu, translate, canvas) {
 
-	  contextPad.registerProvider(LOW_PRIORITY$m, this);
+	  contextPad.registerProvider(LOW_PRIORITY$o, this);
 
 	  this._contextPad = contextPad;
 	  this._popupMenu = popupMenu;
@@ -30404,7 +30448,7 @@
 	 * @typedef {import('../modeling/Modeling.js').default} Modeling
 	 */
 
-	var LOW_PRIORITY$l = 100;
+	var LOW_PRIORITY$n = 100;
 
 
 	/**
@@ -30417,7 +30461,7 @@
 	 */
 	function AutoPlace$1(eventBus, modeling, canvas) {
 
-	  eventBus.on('autoPlace', LOW_PRIORITY$l, function(context) {
+	  eventBus.on('autoPlace', LOW_PRIORITY$n, function(context) {
 	    var shape = context.shape,
 	        source = context.source;
 
@@ -31280,7 +31324,7 @@
 	 * @typedef {import('../../core/EventBus.js').default} EventBus
 	 */
 
-	var HIGH_PRIORITY$l = 1500;
+	var HIGH_PRIORITY$m = 1500;
 
 
 	/**
@@ -31348,7 +31392,7 @@
 	     */
 	    eventBus.on('drag.start', function(event) {
 
-	      eventBus.once('drag.move', HIGH_PRIORITY$l, function(event) {
+	      eventBus.once('drag.move', HIGH_PRIORITY$m, function(event) {
 
 	        ensureHover(event);
 
@@ -31379,7 +31423,7 @@
 	      hover = event.element;
 	    });
 
-	    eventBus.on('element.hover', HIGH_PRIORITY$l, function(event) {
+	    eventBus.on('element.hover', HIGH_PRIORITY$m, function(event) {
 
 	      // (3) am I on an element still?
 	      if (hover) {
@@ -33358,7 +33402,7 @@
 	    MARKER_CONNECT_UPDATING$1 = 'djs-updating',
 	    MARKER_DRAGGER = 'djs-dragging';
 
-	var HIGH_PRIORITY$k = 1100;
+	var HIGH_PRIORITY$l = 1100;
 
 	/**
 	 * Preview connection while moving bendpoints.
@@ -33426,7 +33470,7 @@
 	  eventBus.on([
 	    'bendpoint.move.out',
 	    'bendpoint.move.cleanup'
-	  ], HIGH_PRIORITY$k, function(event) {
+	  ], HIGH_PRIORITY$l, function(event) {
 	    var context = event.context,
 	        hover = context.hover,
 	        target = context.target;
@@ -33512,7 +33556,7 @@
 	  eventBus.on([
 	    'bendpoint.move.end',
 	    'bendpoint.move.cancel'
-	  ], HIGH_PRIORITY$k, function(event) {
+	  ], HIGH_PRIORITY$l, function(event) {
 	    var context = event.context,
 	        connection = context.connection,
 	        draggerGfx = context.draggerGfx,
@@ -34528,8 +34572,8 @@
 	 * @typedef {import('../../core/EventBus.js').default} EventBus
 	 */
 
-	var HIGH_PRIORITY$j = 1100,
-	    LOW_PRIORITY$k = 900;
+	var HIGH_PRIORITY$k = 1100,
+	    LOW_PRIORITY$m = 900;
 
 	var MARKER_OK$3 = 'connect-ok',
 	    MARKER_NOT_OK$3 = 'connect-not-ok';
@@ -34573,7 +34617,7 @@
 	    });
 	  });
 
-	  eventBus.on('connect.hover', LOW_PRIORITY$k, function(event) {
+	  eventBus.on('connect.hover', LOW_PRIORITY$m, function(event) {
 	    var context = event.context,
 	        hover = event.hover,
 	        canExecute = context.canExecute;
@@ -34589,7 +34633,7 @@
 	  eventBus.on([
 	    'connect.out',
 	    'connect.cleanup'
-	  ], HIGH_PRIORITY$j, function(event) {
+	  ], HIGH_PRIORITY$k, function(event) {
 	    var hover = event.hover;
 
 	    if (hover) {
@@ -35641,7 +35685,7 @@
 	 * @typedef {import('../../../model/Types').Element} Element
 	 */
 
-	var HIGH_PRIORITY$i = 1500;
+	var HIGH_PRIORITY$j = 1500;
 
 	/**
 	 * A behavior that ensures that visually enclosed artifacts are affected
@@ -35662,7 +35706,7 @@
 	  injector.invoke(CommandInterceptor, this);
 
 	  // enclosed artifacts are deleted with a container element
-	  this.preExecute('elements.delete', HIGH_PRIORITY$i, function(event) {
+	  this.preExecute('elements.delete', HIGH_PRIORITY$j, function(event) {
 	    var context = event.context,
 	        elements = context.elements;
 
@@ -35775,7 +35819,7 @@
 	 * @typedef {import('didi').Injector} Injector
 	 */
 
-	var LOW_PRIORITY$j = 500;
+	var LOW_PRIORITY$l = 500;
 
 
 	/**
@@ -35791,7 +35835,7 @@
 
 	  var self = this;
 
-	  this.postExecuted('elements.create', LOW_PRIORITY$j, function(context) {
+	  this.postExecuted('elements.create', LOW_PRIORITY$l, function(context) {
 	    var elements = context.elements;
 
 	    elements = elements.filter(function(shape) {
@@ -35814,7 +35858,7 @@
 	  }, true);
 
 
-	  this.preExecute('elements.move', LOW_PRIORITY$j, function(context) {
+	  this.preExecute('elements.move', LOW_PRIORITY$l, function(context) {
 	    var shapes = context.shapes,
 	        host = context.newHost;
 
@@ -35932,6 +35976,255 @@
 
 	e$3(BoundaryEventBehavior, CommandInterceptor);
 
+	/**
+	 * @typedef {import('../../BpmnFactory').default} BpmnFactory
+	 *
+	 * @typedef {import('../../../../model/Types').ModdleElement} ModdleElement
+	 */
+
+	/**
+	 * Creates a new bpmn:CategoryValue inside a new bpmn:Category
+	 *
+	 * @param {BpmnFactory} bpmnFactory
+	 *
+	 * @return {ModdleElement}
+	 */
+	function createCategory(bpmnFactory) {
+	  return bpmnFactory.create('bpmn:Category');
+	}
+
+	/**
+	 * Creates a new bpmn:CategoryValue inside a new bpmn:Category
+	 *
+	 * @param {BpmnFactory} bpmnFactory
+	 *
+	 * @return {ModdleElement}
+	 */
+	function createCategoryValue(bpmnFactory) {
+	  return bpmnFactory.create('bpmn:CategoryValue');
+	}
+
+	/**
+	 * Returns a group's category value, creating one (including a
+	 * category) if needed.
+	 *
+	 * @param {BpmnFactory} bpmnFactory
+	 * @param {ModdleElement} groupBo
+	 *
+	 * @return {ModdleElement}
+	 */
+	function getOrCreateCategoryValueForGroup(bpmnFactory, groupBo) {
+	  var categoryValue = groupBo.get('categoryValueRef');
+
+	  if (!categoryValue) {
+	    categoryValue = groupBo.categoryValueRef = createCategoryValue(bpmnFactory);
+	  }
+
+	  if (!categoryValue.$parent) {
+	    categoryValue.$parent = createCategory(bpmnFactory);
+	  }
+
+	  return categoryValue;
+	}
+
+	/**
+	 * Adds category value to definitions
+	 *
+	 * @param {ModdleElement} categoryValue
+	 * @param {ModdleElement} category
+	 * @param {ModdleElement} definitions
+	 *
+	 * @return {ModdleElement}
+	 */
+	function linkCategoryValue(categoryValue, category, definitions) {
+	  add(category.get('categoryValue'), categoryValue);
+	  categoryValue.$parent = category;
+
+	  add(definitions.get('rootElements'), category);
+	  category.$parent = definitions;
+
+	  return categoryValue;
+	}
+
+	/**
+	 * Unlink category value from parent
+	 *
+	 * @param {ModdleElement} categoryValue
+	 *
+	 * @return {ModdleElement}
+	 */
+	function unlinkCategoryValue(categoryValue) {
+	  var category = categoryValue.$parent;
+
+	  if (category) {
+	    remove(category.get('categoryValue'), categoryValue);
+	    categoryValue.$parent = null;
+	  }
+
+	  return categoryValue;
+	}
+
+	/**
+	 * Unlink category from parent
+	 *
+	 * @param {ModdleElement} category
+	 *
+	 * @return {ModdleElement}
+	 */
+	function unlinkCategory(category) {
+	  var definitions = category.$parent;
+
+	  if (definitions) {
+	    remove(definitions.get('rootElements'), category);
+	    category.$parent = null;
+	  }
+
+	  return category;
+	}
+
+	var LOW_PRIORITY$k = 500;
+
+	/**
+	 * @typedef {import('../../../Modeler').default} Modeler
+	 * @typedef {import('diagram-js/lib/core/ElementRegistry').default} ElementRegistry
+	 * @typedef {import('didi').Injector} Injector
+	 */
+
+	/**
+	 * Maintains a group's category (value) inside definitions#rootElements.
+	 *
+	 * @param {Modeler} bpmnjs
+	 * @param {ElementRegistry} elementRegistry
+	 * @param {Injector} injector
+	 */
+	function CategoryRootElementReferenceBehavior(
+	    bpmnjs, elementRegistry, injector
+	) {
+	  injector.invoke(CommandInterceptor, this);
+
+	  function getGroupBusinessObjects(ignoredBusinessObject) {
+	    return elementRegistry.filter(function(element) {
+	      return is(element, 'bpmn:Group') && !element.labelTarget;
+	    }).map(getBusinessObject).filter(function(businessObject) {
+	      return businessObject !== ignoredBusinessObject;
+	    });
+	  }
+
+	  function isCategoryValueReferenced(categoryValue, ignoredBusinessObject) {
+	    return getGroupBusinessObjects(ignoredBusinessObject).some(function(businessObject) {
+	      return businessObject.get('categoryValueRef') === categoryValue;
+	    });
+	  }
+
+	  function isCategoryReferenced(category, ignoredBusinessObject) {
+	    return getGroupBusinessObjects(ignoredBusinessObject).some(function(businessObject) {
+	      var categoryValue = businessObject.get('categoryValueRef');
+
+	      return categoryValue && categoryValue.$parent === category;
+	    });
+	  }
+
+	  function link(categoryValue, category) {
+	    if (categoryValue && category) {
+	      linkCategoryValue(categoryValue, category, bpmnjs.getDefinitions());
+	    }
+	  }
+
+	  function unlink(categoryValue, category, ignoredBusinessObject) {
+	    if (category && !isCategoryReferenced(category, ignoredBusinessObject)) {
+	      unlinkCategory(category);
+	    }
+
+	    if (categoryValue && !isCategoryValueReferenced(categoryValue, ignoredBusinessObject)) {
+	      unlinkCategoryValue(categoryValue);
+	    }
+	  }
+
+
+	  this.executed([ 'shape.create', 'label.create' ], function(context) {
+	    var shape = context.labelTarget || context.shape;
+
+	    if (!is(shape, 'bpmn:Group') || shape.labelTarget) {
+	      return;
+	    }
+
+	    link(context.categoryValue, context.category);
+	  }, true);
+
+	  this.reverted([ 'shape.create', 'label.create' ], function(context) {
+	    var shape = context.labelTarget || context.shape;
+
+	    if (!is(shape, 'bpmn:Group') || shape.labelTarget) {
+	      return;
+	    }
+
+	    unlink(context.categoryValue, context.category, getBusinessObject(shape));
+	  }, true);
+
+	  this.executed([ 'shape.move', 'shape.resize' ], LOW_PRIORITY$k, function(context) {
+	    link(context.categoryValue, context.category);
+	  }, true);
+
+	  this.reverted([ 'shape.move', 'shape.resize' ], function(context) {
+	    var shape = context.shape;
+
+	    if (context.categoryValue) {
+	      unlink(context.categoryValue, context.category, getBusinessObject(shape));
+	    }
+	  }, true);
+
+	  this.executed('group.updateRefs', function(context) {
+	    getGroupUpdates(context).forEach(function(update) {
+	      link(update.categoryValue, update.category);
+	    });
+	  }, true);
+
+	  this.reverted('group.updateRefs', function(context) {
+	    getGroupUpdates(context).forEach(function(update) {
+	      unlink(
+	        update.categoryValue,
+	        update.category,
+	        getBusinessObject(update.groupShape)
+	      );
+	    });
+	  }, true);
+
+	  this.executed('shape.delete', function(context) {
+	    var shape = context.shape;
+
+	    if (!is(shape, 'bpmn:Group') || shape.labelTarget) {
+	      return;
+	    }
+
+	    unlink(context.categoryValue, context.category, getBusinessObject(shape));
+	  }, true);
+
+	  this.reverted('shape.delete', function(context) {
+	    var shape = context.shape;
+
+	    if (!is(shape, 'bpmn:Group') || shape.labelTarget) {
+	      return;
+	    }
+
+	    link(context.categoryValue, context.category);
+	  }, true);
+	}
+
+	CategoryRootElementReferenceBehavior.$inject = [
+	  'bpmnjs',
+	  'elementRegistry',
+	  'injector'
+	];
+
+	e$3(CategoryRootElementReferenceBehavior, CommandInterceptor);
+
+
+	// helpers //////////
+
+	function getGroupUpdates(context) {
+	  return context.updates?.groups || [];
+	}
+
 	/**
 	 * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
 	 * @typedef {import('../lib/features/modeling/Modeling').default} Modeling
@@ -36228,7 +36521,7 @@
 
 	var PARTICIPANT_BORDER_WIDTH = 30;
 
-	var HIGH_PRIORITY$h = 2000;
+	var HIGH_PRIORITY$i = 2000;
 
 
 	/**
@@ -36245,7 +36538,7 @@
 	  eventBus.on([
 	    'create.start',
 	    'shape.move.start'
-	  ], HIGH_PRIORITY$h, function(event) {
+	  ], HIGH_PRIORITY$i, function(event) {
 	    var context = event.context,
 	        shape = context.shape,
 	        rootElement = canvas.getRootElement();
@@ -36280,7 +36573,7 @@
 	  });
 
 	  // force hovering process when creating first participant
-	  eventBus.on('create.start', HIGH_PRIORITY$h, function(event) {
+	  eventBus.on('create.start', HIGH_PRIORITY$i, function(event) {
 	    var context = event.context,
 	        shape = context.shape,
 	        rootElement = canvas.getRootElement(),
@@ -36292,7 +36585,7 @@
 	    }
 
 	    if (is(shape, 'bpmn:Participant') && is(rootElement, 'bpmn:Process')) {
-	      eventBus.on('element.hover', HIGH_PRIORITY$h, ensureHoveringProcess);
+	      eventBus.on('element.hover', HIGH_PRIORITY$i, ensureHoveringProcess);
 
 	      eventBus.once('create.cleanup', function() {
 	        eventBus.off('element.hover', ensureHoveringProcess);
@@ -36313,7 +36606,7 @@
 
 	  // when creating mutliple elements through `elements.create` parent must be set to collaboration
 	  // and passed to `shape.create` as hint
-	  this.preExecute('elements.create', HIGH_PRIORITY$h, function(context) {
+	  this.preExecute('elements.create', HIGH_PRIORITY$i, function(context) {
 	    var elements = context.elements,
 	        parent = context.parent,
 	        participant = findParticipant(elements),
@@ -37249,7 +37542,7 @@
 	 * @typedef {import('../../space-tool/BpmnSpaceTool').default} SpaceTool
 	 */
 
-	var LOW_PRIORITY$i = 500;
+	var LOW_PRIORITY$j = 500;
 
 
 	/**
@@ -37362,7 +37655,7 @@
 	  /**
 	   * Adjust sizes of other lanes after lane deletion
 	   */
-	  this.postExecuted('shape.delete', LOW_PRIORITY$i, function(event) {
+	  this.postExecuted('shape.delete', LOW_PRIORITY$j, function(event) {
 
 	    var context = event.context,
 	        hints = context.hints,
@@ -37395,7 +37688,7 @@
 	 * @typedef {import('didi').Injector} Injector
 	 */
 
-	var LOW_PRIORITY$h = 500;
+	var LOW_PRIORITY$i = 500;
 
 
 	/**
@@ -37411,7 +37704,7 @@
 
 	  var self = this;
 
-	  this.postExecuted('elements.create', LOW_PRIORITY$h, function(context) {
+	  this.postExecuted('elements.create', LOW_PRIORITY$i, function(context) {
 	    var elements = context.elements;
 
 	    elements.filter(function(shape) {
@@ -37425,7 +37718,7 @@
 	    });
 	  }, true);
 
-	  this.preExecute('elements.move', LOW_PRIORITY$h, function(context) {
+	  this.preExecute('elements.move', LOW_PRIORITY$i, function(context) {
 	    var shapes = context.shapes,
 	        newHost = context.newHost;
 
@@ -37798,7 +38091,7 @@
 	 * @typedef {import('diagram-js/lib/core/Canvas').default} Canvas
 	 */
 
-	var HIGH_PRIORITY$g = 1500;
+	var HIGH_PRIORITY$h = 1500;
 	var HIGHEST_PRIORITY = 2000;
 
 
@@ -37820,7 +38113,7 @@
 	    'shape.move.move',
 	    'shape.move.out',
 	    'shape.move.end'
-	  ], HIGH_PRIORITY$g, function(event) {
+	  ], HIGH_PRIORITY$h, function(event) {
 	    var context = event.context,
 	        shape = context.shape || event.shape,
 	        hover = event.hover;
@@ -37852,7 +38145,7 @@
 	    'global-connect.out',
 	    'global-connect.end',
 	    'global-connect.cleanup'
-	  ], HIGH_PRIORITY$g, function(event) {
+	  ], HIGH_PRIORITY$h, function(event) {
 	    var hover = event.hover;
 
 	    // ensure connections start/end on bpmn:Participant,
@@ -37866,7 +38159,7 @@
 
 	  eventBus.on([
 	    'bendpoint.move.hover'
-	  ], HIGH_PRIORITY$g, function(event) {
+	  ], HIGH_PRIORITY$h, function(event) {
 	    var context = event.context,
 	        hover = event.hover,
 	        type = context.type;
@@ -37882,7 +38175,7 @@
 
 	  eventBus.on([
 	    'connect.start'
-	  ], HIGH_PRIORITY$g, function(event) {
+	  ], HIGH_PRIORITY$h, function(event) {
 	    var context = event.context,
 	        start = context.start;
 
@@ -37921,101 +38214,12 @@
 	  'canvas'
 	];
 
-	/**
-	 * @typedef {import('../../BpmnFactory').default} BpmnFactory
-	 *
-	 * @typedef {import('../../../model/Types').ModdleElement} ModdleElement
-	 */
-
-	/**
-	 * Creates a new bpmn:CategoryValue inside a new bpmn:Category
-	 *
-	 * @param {BpmnFactory} bpmnFactory
-	 *
-	 * @return {ModdleElement}
-	 */
-	function createCategory(bpmnFactory) {
-	  return bpmnFactory.create('bpmn:Category');
-	}
-
-	/**
-	 * Creates a new bpmn:CategoryValue inside a new bpmn:Category
-	 *
-	 * @param {BpmnFactory} bpmnFactory
-	 *
-	 * @return {ModdleElement}
-	 */
-	function createCategoryValue(bpmnFactory) {
-	  return bpmnFactory.create('bpmn:CategoryValue');
-	}
-
-	/**
-	 * Adds category value to definitions
-	 *
-	 * @param {ModdleElement} categoryValue
-	 * @param {ModdleElement} category
-	 * @param {ModdleElement} definitions
-	 *
-	 * @return {ModdleElement}
-	 */
-	function linkCategoryValue(categoryValue, category, definitions) {
-	  add(category.get('categoryValue'), categoryValue);
-	  categoryValue.$parent = category;
-
-	  add(definitions.get('rootElements'), category);
-	  category.$parent = definitions;
-
-	  return categoryValue;
-	}
-
-	/**
-	 * Unlink category value from parent
-	 *
-	 * @param {ModdleElement} categoryValue
-	 *
-	 * @return {ModdleElement}
-	 */
-	function unlinkCategoryValue(categoryValue) {
-	  var category = categoryValue.$parent;
-
-	  if (category) {
-	    remove(category.get('categoryValue'), categoryValue);
-	    categoryValue.$parent = null;
-	  }
-
-	  return categoryValue;
-	}
-
-	/**
-	 * Unlink category from parent
-	 *
-	 * @param {ModdleElement} category
-	 *
-	 * @return {ModdleElement}
-	 */
-	function unlinkCategory(category) {
-	  var definitions = category.$parent;
-
-	  if (definitions) {
-	    remove(definitions.get('rootElements'), category);
-	    category.$parent = null;
-	  }
-
-	  return category;
-	}
-
 	/**
 	 * @typedef {import('../BpmnFactory').default} BpmnFactory
-	 * @typedef {import('../../../Modeler').default} Modeler
-	 * @typedef {import('diagram-js/lib/core/ElementRegistry').default} ElementRegistry
 	 * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
+	 * @typedef {import('diagram-js/lib/core/ElementRegistry').default} ElementRegistry
 	 * @typedef {import('didi').Injector} Injector
 	 * @typedef {import('../../copy-paste/ModdleCopy').default} ModdleCopy
-	 *
-	 * @typedef {import('../../../model/Types').Element} Element
-	 * @typedef {import('../../../model/Types').Shape} Shape
-	 *
-	 * @typedef {import('diagram-js/lib/util/Types').DirectionTRBL} DirectionTRBL
 	 */
 
 	var LOWER_PRIORITY$1 = 770;
@@ -38025,137 +38229,45 @@
 	 * BPMN specific group behavior.
 	 *
 	 * @param {BpmnFactory} bpmnFactory
-	 * @param {Modeler} bpmnjs
-	 * @param {ElementRegistry} elementRegistry
 	 * @param {EventBus} eventBus
 	 * @param {Injector} injector
 	 * @param {ModdleCopy} moddleCopy
 	 */
 	function GroupBehavior(
 	    bpmnFactory,
-	    bpmnjs,
-	    elementRegistry,
 	    eventBus,
 	    injector,
 	    moddleCopy
 	) {
 	  injector.invoke(CommandInterceptor, this);
 
-	  /**
-	   * Returns all group element in the current registry.
-	   *
-	   * @return {Shape[]}
-	   */
-	  function getGroupElements() {
-	    return elementRegistry.filter(function(e) {
-	      return is(e, 'bpmn:Group');
-	    });
-	  }
-
-	  /**
-	   * Returns true if given category is referenced in one of the given elements.
-	   *
-	   * @param {Element[]} elements
-	   * @param {ModdleElement} category
-	   *
-	   * @return {boolean}
-	   */
-	  function isReferencedCategory(elements, category) {
-	    return elements.some(function(element) {
-	      var businessObject = getBusinessObject(element);
-
-	      var _category = businessObject.categoryValueRef && businessObject.categoryValueRef.$parent;
-
-	      return _category === category;
-	    });
-	  }
-
-	  /**
-	   * Returns true if given categoryValue is referenced in one of the given elements.
-	   *
-	   * @param {Element[]} elements
-	   * @param {ModdleElement} categoryValue
-	   *
-	   * @return {boolean}
-	   */
-	  function isReferencedCategoryValue(elements, categoryValue) {
-	    return elements.some(function(element) {
-	      var businessObject = getBusinessObject(element);
-
-	      return businessObject.categoryValueRef === categoryValue;
-	    });
-	  }
-
-	  /**
-	   * Remove category value unless it is still referenced.
-	   *
-	   * @param {ModdleElement} categoryValue
-	   * @param {ModdleElement} category
-	   * @param {ModdleElement} businessObject
-	   */
-	  function removeCategoryValue(categoryValue, category, businessObject) {
-
-	    var groups = getGroupElements().filter(function(element) {
-	      return element.businessObject !== businessObject;
-	    });
-
-	    if (category && !isReferencedCategory(groups, category)) {
-	      unlinkCategory(category);
-	    }
-
-	    if (categoryValue && !isReferencedCategoryValue(groups, categoryValue)) {
-	      unlinkCategoryValue(categoryValue);
-	    }
-	  }
-
-	  /**
-	   * Add category value.
-	   *
-	   * @param {ModdleElement} categoryValue
-	   * @param {ModdleElement} category
-	   *
-	   * @return {ModdleElement}
-	   */
-	  function addCategoryValue(categoryValue, category) {
-	    return linkCategoryValue(categoryValue, category, bpmnjs.getDefinitions());
-	  }
-
 	  function setCategoryValue(element, context) {
 	    var businessObject = getBusinessObject(element),
-	        categoryValue = businessObject.categoryValueRef;
+	        categoryValue = context.categoryValue || businessObject.categoryValueRef;
 
 	    if (!categoryValue) {
-	      categoryValue =
-	      businessObject.categoryValueRef =
-	      context.categoryValue = (
-	        context.categoryValue || createCategoryValue(bpmnFactory)
-	      );
+	      categoryValue = getOrCreateCategoryValueForGroup(bpmnFactory, businessObject);
 	    }
 
-	    var category = categoryValue.$parent;
+	    var category = context.category || categoryValue.$parent || createCategory(bpmnFactory);
 
-	    if (!category) {
-	      category =
-	      categoryValue.$parent =
-	      context.category = (
-	        context.category || createCategory(bpmnFactory)
-	      );
-	    }
+	    businessObject.categoryValueRef = categoryValue;
+	    categoryValue.$parent = category;
 
-	    addCategoryValue(categoryValue, category, bpmnjs.getDefinitions());
+	    context.categoryValue = categoryValue;
+	    context.category = category;
 	  }
 
 	  function unsetCategoryValue(element, context) {
-	    var category = context.category,
-	        categoryValue = context.categoryValue,
-	        businessObject = getBusinessObject(element);
+	    var businessObject = getBusinessObject(element),
+	        categoryValue = context.categoryValue || businessObject.categoryValueRef,
+	        category = context.category || (categoryValue && categoryValue.$parent);
 
 	    if (categoryValue) {
-	      businessObject.categoryValueRef = null;
+	      context.categoryValue = categoryValue;
+	      context.category = category;
 
-	      removeCategoryValue(categoryValue, category, businessObject);
-	    } else {
-	      removeCategoryValue(null, businessObject.categoryValueRef.$parent, businessObject);
+	      businessObject.categoryValueRef = null;
 	    }
 	  }
 
@@ -38197,14 +38309,10 @@
 	      return;
 	    }
 
-	    var categoryValue = context.categoryValue = businessObject.categoryValueRef,
-	        category;
+	    var categoryValue = context.categoryValue = businessObject.categoryValueRef;
 
 	    if (categoryValue) {
-	      category = context.category = categoryValue.$parent;
-
-	      removeCategoryValue(categoryValue, category, businessObject);
-
+	      context.category = categoryValue.$parent;
 	      businessObject.categoryValueRef = null;
 	    }
 	  });
@@ -38224,39 +38332,77 @@
 
 	    if (categoryValue) {
 	      businessObject.categoryValueRef = categoryValue;
-
-	      addCategoryValue(categoryValue, category);
+	      categoryValue.$parent = category;
 	    }
 	  });
 
 
-	  // create new category + value when group was created
+	  // create new category + value when group was created so that visually
+	  // enclosed elements can be categorized against it, even if it is unlabeled
 
 	  this.execute('shape.create', function(event) {
 	    var context = event.context,
-	        shape = context.shape;
+	        shape = context.shape,
+	        hints = context.hints || {};
 
 	    if (!is(shape, 'bpmn:Group') || shape.labelTarget) {
 	      return;
 	    }
 
-	    if (getBusinessObject(shape).categoryValueRef) {
-	      setCategoryValue(shape, context);
+	    // during paste the category value (if any) is carried over from the
+	    // source; only fabricate one for genuinely new groups
+	    if (hints.createElementsBehavior === false &&
+	        !getBusinessObject(shape).categoryValueRef &&
+	        !context.categoryValue) {
+	      return;
 	    }
+
+	    setCategoryValue(shape, context);
 	  });
 
 	  this.reverted('shape.create', function(event) {
 
 	    var context = event.context,
-	        shape = context.shape;
+	        shape = context.shape,
+	        hints = context.hints || {};
 
 	    if (!is(shape, 'bpmn:Group') || shape.labelTarget) {
 	      return;
 	    }
 
-	    if (getBusinessObject(shape).categoryValueRef) {
-	      unsetCategoryValue(shape, context);
+	    if (hints.createElementsBehavior === false &&
+	        !getBusinessObject(shape).categoryValueRef &&
+	        !context.categoryValue) {
+	      return;
 	    }
+
+	    unsetCategoryValue(shape, context);
+	  });
+
+
+	  // add category -> categoryValue for groups when they change
+
+	  this.executed([ 'shape.move', 'shape.resize' ], function(event) {
+	    var context = event.context,
+	        shape = context.shape;
+
+	    if (!is(shape, 'bpmn:Group') || shape.labelTarget ||
+	        getBusinessObject(shape).categoryValueRef) {
+	      return;
+	    }
+
+	    setCategoryValue(shape, context);
+	  });
+
+	  this.reverted([ 'shape.move', 'shape.resize' ], function(event) {
+	    var context = event.context,
+	        shape = context.shape;
+
+	    if (!is(shape, 'bpmn:Group') || shape.labelTarget || !context.categoryValue) {
+	      return;
+	    }
+
+	    unsetCategoryValue(shape, context);
 	  });
 
 
@@ -38312,8 +38458,6 @@
 
 	GroupBehavior.$inject = [
 	  'bpmnFactory',
-	  'bpmnjs',
-	  'elementRegistry',
 	  'eventBus',
 	  'injector',
 	  'moddleCopy'
@@ -40368,7 +40512,7 @@
 	  'selection'
 	];
 
-	var HIGH_PRIORITY$f = 1500;
+	var HIGH_PRIORITY$g = 1500;
 
 	/**
 	 * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
@@ -40421,7 +40565,7 @@
 	 * @param {EventBus} eventBus
 	 */
 	function ResizeBehavior$1(eventBus) {
-	  eventBus.on('resize.start', HIGH_PRIORITY$f, function(event) {
+	  eventBus.on('resize.start', HIGH_PRIORITY$g, function(event) {
 	    var context = event.context,
 	        shape = context.shape,
 	        direction = context.direction,
@@ -40693,7 +40837,7 @@
 	 * @typedef {import('diagram-js/lib/util/Types').DirectionTRBL} DirectionTRBL
 	 */
 
-	var LOW_PRIORITY$g = 500;
+	var LOW_PRIORITY$h = 500;
 
 
 	/**
@@ -40823,7 +40967,7 @@
 	    }
 	  });
 
-	  eventBus.on('copyPaste.pasteElement', LOW_PRIORITY$g, function(context) {
+	  eventBus.on('copyPaste.pasteElement', LOW_PRIORITY$h, function(context) {
 	    var descriptor = context.descriptor,
 	        businessObject = descriptor.businessObject,
 	        referencedRootElement = descriptor.referencedRootElement;
@@ -41068,8 +41212,8 @@
 	 * @typedef {import('../../../model/Types').ModdleElement} ModdleElement
 	 */
 
-	var LOW_PRIORITY$f = 400;
-	var HIGH_PRIORITY$e = 600;
+	var LOW_PRIORITY$g = 400;
+	var HIGH_PRIORITY$f = 600;
 
 	var DEFAULT_POSITION = {
 	  x: 180,
@@ -41343,7 +41487,7 @@
 
 
 	  // create/remove plane for the subprocess
-	  this.executed('shape.toggleCollapse', LOW_PRIORITY$f, function(context) {
+	  this.executed('shape.toggleCollapse', LOW_PRIORITY$g, function(context) {
 	    var shape = context.shape;
 
 	    if (!is(shape, 'bpmn:SubProcess')) {
@@ -41361,7 +41505,7 @@
 
 
 	  // create/remove plane for the subprocess
-	  this.reverted('shape.toggleCollapse', LOW_PRIORITY$f, function(context) {
+	  this.reverted('shape.toggleCollapse', LOW_PRIORITY$g, function(context) {
 	    var shape = context.shape;
 
 	    if (!is(shape, 'bpmn:SubProcess')) {
@@ -41378,7 +41522,7 @@
 	  }, true);
 
 	  // move elements between planes
-	  this.postExecuted('shape.toggleCollapse', HIGH_PRIORITY$e, function(context) {
+	  this.postExecuted('shape.toggleCollapse', HIGH_PRIORITY$f, function(context) {
 	    var shape = context.shape;
 
 	    if (!is(shape, 'bpmn:SubProcess')) {
@@ -41925,7 +42069,7 @@
 	 * @typedef {import('../Modeling').default} Modeling
 	 */
 
-	var LOW_PRIORITY$e = 500;
+	var LOW_PRIORITY$f = 500;
 
 	/**
 	 * @param {EventBus} eventBus
@@ -41986,7 +42130,7 @@
 	    };
 	  }
 
-	  this.executed([ 'shape.toggleCollapse' ], LOW_PRIORITY$e, function(e) {
+	  this.executed([ 'shape.toggleCollapse' ], LOW_PRIORITY$f, function(e) {
 
 	    var context = e.context,
 	        shape = context.shape;
@@ -42009,7 +42153,7 @@
 	    }
 	  });
 
-	  this.reverted([ 'shape.toggleCollapse' ], LOW_PRIORITY$e, function(e) {
+	  this.reverted([ 'shape.toggleCollapse' ], LOW_PRIORITY$f, function(e) {
 
 	    var context = e.context;
 	    var shape = context.shape;
@@ -42024,7 +42168,7 @@
 	    }
 	  });
 
-	  this.postExecuted([ 'shape.toggleCollapse' ], LOW_PRIORITY$e, function(e) {
+	  this.postExecuted([ 'shape.toggleCollapse' ], LOW_PRIORITY$f, function(e) {
 	    var shape = e.context.shape,
 	        defaultSize = elementFactory.getDefaultSize(shape),
 	        newBounds;
@@ -42179,12 +42323,31 @@
 	 * @typedef {import('../Modeling').default} Modeling
 	 */
 
-	var LOW_PRIORITY$d = 500,
-	    HIGH_PRIORITY$d = 5000;
+	var LOW_PRIORITY$e = 500,
+	    HIGH_PRIORITY$e = 5000;
+
+	// Commands that provide a shape whose lane references must be updated.
+	var laneRefShapeEvents = [
+	  'shape.create',
+	  'shape.delete',
+	  'shape.move',
+	  'shape.resize'
+	];
 
+	// Commands that bracket a complete lane reference update, including nested commands.
+	var laneRefUpdateEvents = [
+	  ...laneRefShapeEvents,
+	  'spaceTool',
+	  'lane.add',
+	  'lane.resize',
+	  'lane.split',
+	  'elements.create',
+	  'elements.delete',
+	  'elements.move'
+	];
 
 	/**
-	 * BPMN specific delete lane behavior.
+	 * Synchronizes lane flow node references after geometry changes.
 	 *
 	 * @param {EventBus} eventBus
 	 * @param {Modeling} modeling
@@ -42193,18 +42356,11 @@
 
 	  CommandInterceptor.call(this, eventBus);
 
-	  /**
-	   * Update Lane#flowNodeRefs and FlowNode#lanes with every flow node
-	   * move/resize and lane move/resize. Groups elements to recompute containments
-	   * as efficient as possible.
-	   */
-
-	  // the update context
 	  var context;
 
 
 	  function initContext() {
-	    context = context || new UpdateContext();
+	    context = context || new UpdateContext$1();
 	    context.enter();
 
 	    return context;
@@ -42236,40 +42392,26 @@
 	  }
 
 
-	  var laneRefUpdateEvents = [
-	    'spaceTool',
-	    'lane.add',
-	    'lane.resize',
-	    'lane.split',
-	    'elements.create',
-	    'elements.delete',
-	    'elements.move',
-	    'shape.create',
-	    'shape.delete',
-	    'shape.move',
-	    'shape.resize'
-	  ];
-
-
-	  // listen to a lot of stuff to group lane updates
-
-	  this.preExecute(laneRefUpdateEvents, HIGH_PRIORITY$d, function(event) {
+	  /**
+	   * Sets up the context for lane reference updates before executing commands
+	   * that may affect them.
+	   */
+	  this.preExecute(laneRefUpdateEvents, HIGH_PRIORITY$e, function() {
 	    initContext();
 	  });
 
-	  this.postExecuted(laneRefUpdateEvents, LOW_PRIORITY$d, function(event) {
+	  /**
+	   * Releases the context for lane reference updates after executing commands
+	   * that may affect them.
+	   */
+	  this.postExecuted(laneRefUpdateEvents, LOW_PRIORITY$e, function() {
 	    releaseContext();
 	  });
 
-
-	  // Mark flow nodes + lanes that need an update
-
-	  this.preExecute([
-	    'shape.create',
-	    'shape.move',
-	    'shape.delete',
-	    'shape.resize'
-	  ], function(event) {
+	  /**
+	   * Handles updates to lane references for shapes.
+	   */
+	  this.preExecute(laneRefShapeEvents, function(event) {
 
 	    var context = event.context,
 	        shape = context.shape;
@@ -42277,7 +42419,7 @@
 	    var updateContext = getContext();
 
 	    // no need to update labels
-	    if (shape.labelTarget) {
+	    if (!shape || shape.labelTarget) {
 	      return;
 	    }
 
@@ -42299,7 +42441,7 @@
 	e$3(UpdateFlowNodeRefsBehavior, CommandInterceptor);
 
 
-	function UpdateContext() {
+	function UpdateContext$1() {
 
 	  this.flowNodes = [];
 	  this.lanes = [];
@@ -42325,6 +42467,168 @@
 	  };
 	}
 
+	/**
+	 * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
+	 * @typedef {import('../Modeling').default} Modeling
+	 */
+
+	var LOW_PRIORITY$d = 500,
+	    HIGH_PRIORITY$d = 5000;
+
+	// Commands that provide a shape or connection whose references must be updated.
+	var categoryValueRefShapeAndConnectionEvents = [
+	  'connection.create',
+	  'connection.delete',
+	  'connection.layout',
+	  'connection.move',
+	  'connection.reconnect',
+	  'connection.updateWaypoints',
+	  'shape.create',
+	  'shape.delete',
+	  'shape.move',
+	  'shape.resize'
+	];
+
+	// Commands that bracket a complete reference update, including nested commands.
+	var categoryValueRefUpdateEvents = [
+	  ...categoryValueRefShapeAndConnectionEvents,
+	  'elements.create',
+	  'elements.delete',
+	  'elements.move',
+	  'label.create',
+	  'spaceTool'
+	];
+
+	/**
+	 * Synchronizes group category references after geometry changes.
+	 *
+	 * @param {EventBus} eventBus
+	 * @param {Modeling} modeling
+	 */
+	function UpdateCategoryValueRefsBehavior(eventBus, modeling) {
+
+	  CommandInterceptor.call(this, eventBus);
+
+	  var context;
+
+	  function initContext() {
+	    context = context || new UpdateContext();
+	    context.enter();
+
+	    return context;
+	  }
+
+	  function getContext() {
+	    if (!context) {
+	      throw new Error('out of bounds release');
+	    }
+
+	    return context;
+	  }
+
+	  function releaseContext() {
+	    if (!context) {
+	      throw new Error('out of bounds release');
+	    }
+
+	    var triggerUpdate = context.leave();
+
+	    if (triggerUpdate) {
+	      modeling.updateCategoryValueRefs(
+	        Array.from(context.affectedFlowElements),
+	        Array.from(context.affectedGroupEntries.values())
+	      );
+
+	      context = null;
+	    }
+
+	    return triggerUpdate;
+	  }
+
+	  /**
+	   * Sets up the context for category value reference updates before executing
+	   * commands that may affect them.
+	   */
+	  this.preExecute(categoryValueRefUpdateEvents, HIGH_PRIORITY$d, function() {
+	    initContext();
+	  });
+
+	  /**
+	   * Releases the context for category value reference updates after executing
+	   * commands that may affect them.
+	   */
+	  this.postExecuted(categoryValueRefUpdateEvents, LOW_PRIORITY$d, function() {
+	    releaseContext();
+	  });
+
+	  /**
+	   * Handles updates to category value references for shapes and connections.
+	   */
+	  this.preExecute(categoryValueRefShapeAndConnectionEvents, function(event) {
+	    var shape = event.context.connection || event.context.shape,
+	        updateContext = getContext();
+
+	    if (!shape || shape.labelTarget) {
+	      return;
+	    }
+
+	    if (is(shape, 'bpmn:FlowElement')) {
+	      updateContext.addFlowElement(shape);
+	    }
+
+	    if (is(shape, 'bpmn:Group')) {
+	      updateContext.addGroup(shape);
+	    }
+	  });
+
+	  this.preExecute('label.create', function(event) {
+	    var labelTarget = event.context.labelTarget;
+
+	    if (is(labelTarget, 'bpmn:Group')) {
+	      getContext().addGroup(labelTarget);
+	    }
+	  });
+	}
+
+	UpdateCategoryValueRefsBehavior.$inject = [
+	  'eventBus',
+	  'modeling'
+	];
+
+	e$3(UpdateCategoryValueRefsBehavior, CommandInterceptor);
+
+
+	function UpdateContext() {
+
+	  this.affectedFlowElements = new Set();
+	  this.affectedGroupEntries = new Map();
+
+	  this.counter = 0;
+
+	  this.addFlowElement = function(flowElement) {
+	    this.affectedFlowElements.add(flowElement);
+	  };
+
+	  this.addGroup = function(group) {
+	    if (!this.affectedGroupEntries.has(group)) {
+	      this.affectedGroupEntries.set(group, {
+	        categoryValue: group.businessObject.categoryValueRef,
+	        groupShape: group
+	      });
+	    }
+	  };
+
+	  this.enter = function() {
+	    this.counter++;
+	  };
+
+	  this.leave = function() {
+	    this.counter--;
+
+	    return !this.counter;
+	  };
+	}
+
 	/**
 	 * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
 	 * @typedef {import('../../rules/BpmnRules').default} BpmnRules
@@ -42396,6 +42700,7 @@
 	    'associationBehavior',
 	    'attachEventBehavior',
 	    'boundaryEventBehavior',
+	    'categoryRootElementReferenceBehavior',
 	    'compensateBoundaryEventBehaviour',
 	    'createBehavior',
 	    'createDataObjectBehavior',
@@ -42430,6 +42735,7 @@
 	    'toggleElementCollapseBehaviour',
 	    'unclaimIdBehavior',
 	    'updateFlowNodeRefsBehavior',
+	    'updateCategoryValueRefsBehavior',
 	    'unsetDefaultFlowBehavior',
 	    'setCompensationActivityAfterPasteBehavior'
 	  ],
@@ -42439,6 +42745,7 @@
 	  attachEventBehavior: [ 'type', AttachEventBehavior ],
 	  artifactBehavior: [ 'type', ArtifactBehavior ],
 	  boundaryEventBehavior: [ 'type', BoundaryEventBehavior ],
+	  categoryRootElementReferenceBehavior: [ 'type', CategoryRootElementReferenceBehavior ],
 	  compensateBoundaryEventBehaviour: [ 'type', CompensateBoundaryEventBehavior ],
 	  createBehavior: [ 'type', CreateBehavior ],
 	  createDataObjectBehavior: [ 'type', CreateDataObjectBehavior ],
@@ -42474,6 +42781,7 @@
 	  unclaimIdBehavior: [ 'type', UnclaimIdBehavior ],
 	  unsetDefaultFlowBehavior: [ 'type', DeleteSequenceFlowBehavior ],
 	  updateFlowNodeRefsBehavior: [ 'type', UpdateFlowNodeRefsBehavior ],
+	  updateCategoryValueRefsBehavior: [ 'type', UpdateCategoryValueRefsBehavior ],
 	  setCompensationActivityAfterPasteBehavior: [ 'type', SetCompensationActivityAfterPasteBehavior ]
 	};
 
@@ -43652,9 +43960,47 @@
 	    return false;
 	  }
 
+	  // do not copy message flows unless both connected participants are copied,
+	  // too; otherwise they would end up in an invalid organizational context
+	  if (is(element, 'bpmn:MessageFlow') && !canCopyMessageFlow(elements, element)) {
+	    return false;
+	  }
+
 	  return true;
 	}
 
+	/**
+	 * A message flow may only be copied if both of its participants are copied,
+	 * too. Otherwise it would be pasted into an invalid organizational context,
+	 * e.g. a plain process.
+	 *
+	 * @param {Element[]} elements
+	 * @param {Connection} connection
+	 *
+	 * @return {boolean}
+	 */
+	function canCopyMessageFlow(elements, connection) {
+	  var sourceParticipant = getParticipant(connection.source),
+	      targetParticipant = getParticipant(connection.target);
+
+	  return includes$2(elements, sourceParticipant) && includes$2(elements, targetParticipant);
+	}
+
+	/**
+	 * @param {Element} element
+	 *
+	 * @return {Element|null}
+	 */
+	function getParticipant(element) {
+	  for (; element; element = element.parent) {
+	    if (is(element, 'bpmn:Participant')) {
+	      return element;
+	    }
+	  }
+
+	  return null;
+	}
+
 	/**
 	 * @param {Element} element
 	 *
@@ -53559,8 +53905,6 @@
 	/**
 	 * @typedef {import('diagram-js/lib/command/CommandHandler').default} CommandHandler
 	 *
-	 * @typedef {import('diagram-js/lib/core/ElementRegistry').default} ElementRegistry
-	 *
 	 * @typedef {import('../../../model/Types').Shape} Shape
 	 */
 
@@ -53573,15 +53917,9 @@
 	 *
 	 * @implements {CommandHandler}
 	 *
-	 * @param {ElementRegistry} elementRegistry
 	 */
-	function UpdateFlowNodeRefsHandler(elementRegistry) {
-	  this._elementRegistry = elementRegistry;
-	}
+	function UpdateFlowNodeRefsHandler() {}
 
-	UpdateFlowNodeRefsHandler.$inject = [
-	  'elementRegistry'
-	];
 
 	/**
 	 * @param {Shape} flowNodeShapes
@@ -53757,6 +54095,409 @@
 	  return [];
 	};
 
+	/**
+	 * @typedef {import('diagram-js/lib/command/CommandHandler').default} CommandHandler
+	 * @typedef {import('diagram-js/lib/core/ElementRegistry').default} ElementRegistry
+	 * @typedef {import('../BpmnFactory').default} BpmnFactory
+	 *
+	 * @typedef {import('../../../model/Types').Element} Element
+	 * @typedef {import('../../../model/Types').ModdleElement} ModdleElement
+	 *
+	 * @typedef { {
+	 *   categoryValue: ModdleElement;
+	 *   root?: Element;
+	 * } } CategoryGroupEntry
+	 */
+
+	var CATEGORY_VALUE_REFS_ATTR = 'categoryValueRef';
+
+
+	/**
+	 * Updates category value references for flow elements visually enclosed by groups.
+	 *
+	 * A flow element is grouped only when it shares the group's diagram root and
+	 * is geometrically enclosed by the group. Consequently, visible children of an
+	 * expanded subprocess are grouped, while children of a collapsed subprocess
+	 * are not.
+	 *
+	 * Groups without a category value are auto-healed: if such a group visually
+	 * encloses an affected flow element a category value is created for it on the
+	 * fly, so that legacy diagrams (groups modeled without a category value) start
+	 * to categorize their contents as soon as they are interacted with.
+	 *
+	 * @implements {CommandHandler}
+	 *
+	 * @param {BpmnFactory} bpmnFactory
+	 * @param {ElementRegistry} elementRegistry
+	 */
+	function UpdateCategoryValueRefsHandler(bpmnFactory, elementRegistry) {
+	  this._bpmnFactory = bpmnFactory;
+	  this._elementRegistry = elementRegistry;
+	}
+
+	UpdateCategoryValueRefsHandler.$inject = [
+	  'bpmnFactory',
+	  'elementRegistry'
+	];
+
+
+	/**
+	 * @param { Element[] } affectedFlowElements
+	 * @param { {
+	 *   categoryValue: ModdleElement;
+	 *   groupShape: Element;
+	 * }[] } affectedGroupEntries
+	 *
+	 * @return { {
+	 *   flowElements: {
+	 *     businessObject: ModdleElement;
+	 *     categoryValuesToAdd: ModdleElement[];
+	 *     categoryValuesToRemove: ModdleElement[];
+	 *   }[];
+	 *   groups: {
+	 *     groupShape: Element;
+	 *     categoryValue: ModdleElement;
+	 *     category: ModdleElement;
+	 *   }[];
+	 * } }
+	 */
+	UpdateCategoryValueRefsHandler.prototype._computeUpdates = function(affectedFlowElements, affectedGroupEntries) {
+	  var elementRegistry = this._elementRegistry,
+	      bpmnFactory = this._bpmnFactory;
+
+	  /** @type {Map<Element, ModdleElement>} */
+	  var flowElementBusinessObjects = new Map();
+
+	  var groupUpdates = [];
+
+	  /**
+	   * @type {Map<Element, {
+	   *   present?: CategoryGroupEntry;
+	   *   past?: CategoryGroupEntry;
+	   * }>}
+	   */
+	  var categoryGroups = new Map();
+
+	  /**
+	   * Adds a group to the list of groups to consider for category value updates.
+	   *
+	   * @param {Element} groupShape
+	   * @param {ModdleElement} categoryValue
+	   * @param {boolean} isPresent
+	   */
+	  function addGroup(groupShape, categoryValue, isPresent) {
+	    if (!categoryValue) {
+	      return;
+	    }
+
+	    var categoryGroup = categoryGroups.get(groupShape);
+
+	    if (!categoryGroup) {
+	      categoryGroup = {};
+	      categoryGroups.set(groupShape, categoryGroup);
+	    }
+
+	    if (isPresent && categoryGroup.present) {
+	      return;
+	    }
+
+	    if (!isPresent && categoryGroup.past) {
+	      return;
+	    }
+
+	    if (isPresent) {
+	      categoryGroup.present = {
+	        categoryValue: categoryValue,
+	        root: getRoot(groupShape)
+	      };
+	    } else {
+	      categoryGroup.past = {
+	        categoryValue: categoryValue
+	      };
+	    }
+	  }
+
+	  /**
+	   * Adds a flow element to the list of flow elements to consider for category
+	   * value updates.
+	   *
+	   * @param {Element} flowElement
+	   */
+	  function addFlowElement(flowElement) {
+	    flowElementBusinessObjects.set(
+	      flowElement,
+	      getBusinessObject(flowElement)
+	    );
+	  }
+
+	  /**
+	   * Adds all flow elements on the diagram to the list of flow elements to
+	   * consider; skips root elements (e.g. sub process planes) which share a
+	   * business object with their collapsed shape but carry no diagram position.
+	   */
+	  function addAllFlowElements() {
+	    elementRegistry.filter(function(element) {
+	      return is(element, 'bpmn:FlowElement') && !isLabel(element) && element.parent;
+	    }).forEach(addFlowElement);
+	  }
+
+	  /**
+	   * Returns a group's category value, creating one on the fly for
+	   * legacy groups modeled without one. Retrieving the value in order to
+	   * reference it materializes it; the fresh value is recorded as a heal so
+	   * CategoryRootElementReferenceBehavior can maintain its root element.
+	   *
+	   * @param {Element} groupShape
+	   *
+	   * @return {ModdleElement}
+	   */
+	  function getCategoryValue(groupShape) {
+	    var groupBo = getBusinessObject(groupShape),
+	        categoryValue = groupBo.get('categoryValueRef');
+
+	    if (!categoryValue) {
+	      categoryValue = getOrCreateCategoryValueForGroup(bpmnFactory, groupBo);
+
+	      groupUpdates.push(createGroupUpdate(groupShape, categoryValue));
+	    }
+
+	    return categoryValue;
+	  }
+
+	  function getElementsByRoot(elements) {
+	    return elements.reduce(function(elementsByRoot, element) {
+	      var root = getRoot(element),
+	          elementsInRoot = elementsByRoot.get(root);
+
+	      if (!elementsInRoot) {
+	        elementsInRoot = [];
+	        elementsByRoot.set(root, elementsInRoot);
+	      }
+
+	      elementsInRoot.push(element);
+
+	      return elementsByRoot;
+	    }, new Map());
+	  }
+
+	  affectedFlowElements = Array.from(affectedFlowElements || []);
+
+	  var affectedFlowElementsByRoot = getElementsByRoot(affectedFlowElements);
+
+	  // when a group is moved, resized, added or removed, the category value
+	  // references of all flow elements must be rechecked
+	  if (affectedGroupEntries.length) {
+	    addAllFlowElements();
+	  }
+
+	  // flow elements that were genuinely moved or created; unrelated groups
+	  // will not be touched
+	  affectedFlowElements.forEach(addFlowElement);
+
+	  // add all present groups to the list of groups to consider for category
+	  // value updates, auto-healing legacy groups only when an affected flow
+	  // element moves into them
+	  elementRegistry.filter(function(element) {
+	    return is(element, 'bpmn:Group') && !isLabel(element) && element.parent;
+	  }).forEach(function(groupShape) {
+	    var categoryValue = getBusinessObject(groupShape).get('categoryValueRef');
+
+	    if (!categoryValue) {
+	      var groupRoot = getRoot(groupShape),
+	          affectedFlowElementsInRoot = affectedFlowElementsByRoot.get(groupRoot) || [],
+	          enclosedAffectedFlowElements = getEnclosedElements(
+	            affectedFlowElementsInRoot,
+	            groupShape
+	          ),
+	          enclosesAffectedFlowElement = Object.keys(enclosedAffectedFlowElements).length > 0;
+
+	      if (enclosesAffectedFlowElement) {
+	        categoryValue = getCategoryValue(groupShape);
+	      }
+	    }
+
+	    addGroup(groupShape, categoryValue, true);
+	  });
+
+	  affectedGroupEntries.forEach(function(groupEntry) {
+	    addGroup(groupEntry.groupShape, groupEntry.categoryValue, false);
+	  });
+
+	  // a healed group receives a fresh category value; recheck all flow elements
+	  // so that everything it visually encloses is tagged consistently, not just
+	  // the flow element that triggered the healing
+	  if (groupUpdates.length) {
+	    addAllFlowElements();
+	  }
+
+	  var flowElements = Array.from(flowElementBusinessObjects.keys());
+
+	  var managedCategoryValues = Array.from(categoryGroups.values()).reduce(function(set, group) {
+	    if (group.present) {
+	      set.add(group.present.categoryValue);
+	    }
+
+	    if (group.past) {
+	      set.add(group.past.categoryValue);
+	    }
+
+	    return set;
+	  }, new Set());
+
+	  var categoryValuesByFlowElement = new Map(),
+	      flowElementsByRoot = getElementsByRoot(flowElements);
+
+	  // Containment is calculated once per group and diagram root. This avoids
+	  // allocating an enclosure result for every flow element / group pair.
+	  categoryGroups.forEach(function(categoryGroup, groupShape) {
+	    var presentGroup = categoryGroup.present;
+
+	    if (!presentGroup) {
+	      return;
+	    }
+
+	    var flowElementsInRoot = flowElementsByRoot.get(presentGroup.root) || [],
+	        enclosedFlowElements = getEnclosedElements(flowElementsInRoot, groupShape);
+
+	    flowElementsInRoot.forEach(function(flowElement) {
+	      if (!enclosedFlowElements[flowElement.id]) {
+	        return;
+	      }
+
+	      var categoryValues = categoryValuesByFlowElement.get(flowElement);
+
+	      if (!categoryValues) {
+	        categoryValues = new Set();
+	        categoryValuesByFlowElement.set(flowElement, categoryValues);
+	      }
+
+	      categoryValues.add(presentGroup.categoryValue);
+	    });
+	  });
+
+	  // compute updates for all flow elements based on the groups they are inside
+	  var flowElementUpdates = flowElements.reduce(function(flowElementUpdates, flowElement) {
+	    var flowElementBo = flowElementBusinessObjects.get(flowElement),
+	        categoryValueRefs = flowElementBo.get(CATEGORY_VALUE_REFS_ATTR),
+	        categoryValueRefSet = new Set(categoryValueRefs),
+	        enclosingCategoryValues = categoryValuesByFlowElement.get(flowElement) || new Set(),
+	        categoryValuesToAdd = Array.from(enclosingCategoryValues).filter(function(categoryValue) {
+	          return !categoryValueRefSet.has(categoryValue);
+	        }),
+	        categoryValuesToRemove = categoryValueRefs.filter(function(categoryValue) {
+	          return managedCategoryValues.has(categoryValue) &&
+	            !enclosingCategoryValues.has(categoryValue);
+	        });
+
+	    if (categoryValuesToAdd.length || categoryValuesToRemove.length) {
+	      flowElementUpdates.push({
+	        businessObject: flowElementBo,
+	        categoryValuesToAdd,
+	        categoryValuesToRemove
+	      });
+	    }
+
+	    return flowElementUpdates;
+	  }, []);
+
+	  return {
+	    flowElements: flowElementUpdates,
+	    groups: groupUpdates
+	  };
+	};
+
+
+	UpdateCategoryValueRefsHandler.prototype.execute = function(context) {
+	  var updates = context.updates;
+
+	  if (!updates) {
+	    updates = context.updates = this._computeUpdates(
+	      context.affectedFlowElements,
+	      context.affectedGroupEntries
+	    );
+	  }
+
+	  // set auto-healed category values first so that flow element updates can
+	  // reference them; root element linking is handled by
+	  // CategoryRootElementReferenceBehavior
+	  applyGroupUpdates(updates.groups);
+
+	  applyFlowElementUpdates(updates.flowElements);
+
+	  return [];
+	};
+
+
+	UpdateCategoryValueRefsHandler.prototype.revert = function(context) {
+	  var updates = context.updates;
+
+	  revertFlowElementUpdates(updates.flowElements);
+
+	  revertGroupUpdates(updates.groups);
+
+	  return [];
+	};
+
+
+	function createGroupUpdate(groupShape, categoryValue) {
+	  return {
+	    groupShape: groupShape,
+	    categoryValue: categoryValue,
+	    category: categoryValue.$parent
+	  };
+	}
+
+	function applyGroupUpdates(groupUpdates) {
+	  groupUpdates.forEach(function(groupUpdate) {
+	    getBusinessObject(groupUpdate.groupShape).categoryValueRef = groupUpdate.categoryValue;
+	    groupUpdate.categoryValue.$parent = groupUpdate.category;
+	  });
+	}
+
+	function revertGroupUpdates(groupUpdates) {
+	  groupUpdates.forEach(function(groupUpdate) {
+	    getBusinessObject(groupUpdate.groupShape).categoryValueRef = null;
+	  });
+	}
+
+	function applyFlowElementUpdates(flowElementUpdates) {
+	  flowElementUpdates.forEach(function(flowElementUpdate) {
+	    var businessObject = flowElementUpdate.businessObject,
+	        categoryValueRefs = businessObject.get(CATEGORY_VALUE_REFS_ATTR);
+
+	    flowElementUpdate.categoryValuesToRemove.forEach(function(categoryValue) {
+	      remove(categoryValueRefs, categoryValue);
+	    });
+
+	    flowElementUpdate.categoryValuesToAdd.forEach(function(categoryValue) {
+	      add(categoryValueRefs, categoryValue, true);
+	    });
+	  });
+	}
+
+	function revertFlowElementUpdates(flowElementUpdates) {
+	  flowElementUpdates.forEach(function(flowElementUpdate) {
+	    var businessObject = flowElementUpdate.businessObject,
+	        categoryValueRefs = businessObject.get(CATEGORY_VALUE_REFS_ATTR);
+
+	    flowElementUpdate.categoryValuesToAdd.forEach(function(categoryValue) {
+	      remove(categoryValueRefs, categoryValue);
+	    });
+
+	    flowElementUpdate.categoryValuesToRemove.forEach(function(categoryValue) {
+	      add(categoryValueRefs, categoryValue, true);
+	    });
+	  });
+	}
+
+	function getRoot(element) {
+	  while (element.parent) {
+	    element = element.parent;
+	  }
+
+	  return element;
+	}
+
 	/**
 	 * @typedef {import('diagram-js/lib/command/CommandHandler').default} CommandHandler
 	 *
@@ -54117,6 +54858,11 @@
 	 * @typedef { {
 	 *   removeShape?: boolean;
 	 * } } UpdateLabelHints
+	 *
+	 * @typedef { {
+	 *   categoryValue?: ModdleElement;
+	 *   groupShape: Shape;
+	 * } } GroupEntry
 	 */
 
 	/**
@@ -54167,6 +54913,7 @@
 	  handlers['lane.resize'] = ResizeLaneHandler;
 	  handlers['lane.split'] = SplitLaneHandler;
 	  handlers['lane.updateRefs'] = UpdateFlowNodeRefsHandler;
+	  handlers['group.updateRefs'] = UpdateCategoryValueRefsHandler;
 	  handlers['id.updateClaim'] = IdClaimHandler;
 	  handlers['element.setColor'] = SetColorHandler;
 	  handlers['element.updateLabel'] = UpdateLabelHandler;
@@ -54344,6 +55091,20 @@
 	  });
 	};
 
+	/**
+	 * Update the referenced category values of each flow element.
+	 *
+	 * @param {Element[]} affectedFlowElements The flow elements to update.
+	 * @param {GroupEntry[]} affectedGroupEntries The groups to update.
+	 */
+	Modeling.prototype.updateCategoryValueRefs = function(affectedFlowElements, affectedGroupEntries) {
+
+	  this._commandStack.execute('group.updateRefs', {
+	    affectedFlowElements: affectedFlowElements,
+	    affectedGroupEntries: affectedGroupEntries
+	  });
+	};
+
 	/**
 	 * Claim an ID.
 	 *
@@ -62350,6 +63111,13 @@
 	   * @param {Element} element
 	   */
 	  function createElementOutline(element) {
+
+	    // root elements have no outline; creating one would append a never-updated
+	    // rect to the untransformed root layer, polluting getActiveLayer().getBBox()
+	    if (isRoot(element)) {
+	      return;
+	    }
+
 	    self.createOutline(element);
 	  }