@aranzatech/diagrams-bpmn 0.3.4 → 0.3.6

package/dist/layout/index.cjs

@@ -1,23 +1,626 @@
 'use strict';
 
+var layout = require('@aranzatech/diagrams-core/layout');
 var diagramsCore = require('@aranzatech/diagrams-core');
 require('@aranzatech/diagrams-core/serialization');
-var layout = require('@aranzatech/diagrams-core/layout');
 
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+// src/layout/index.ts
 
 // src/elements/catalog.ts
+var BPMN_ELEMENT_CATALOG = {
+  // ─── Events ──────────────────────────────────────────────────────────────────
+  StartEvent: {
+    label: "Start Event",
+    icon: "Circle",
+    category: "event",
+    defaultWidth: 36,
+    defaultHeight: 36,
+    handlePolicy: "source",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    eventSemantics: "start",
+    canBeStart: true,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 1
+  },
+  EndEvent: {
+    label: "End Event",
+    icon: "CircleDot",
+    category: "event",
+    defaultWidth: 36,
+    defaultHeight: 36,
+    handlePolicy: "target",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    eventSemantics: "end",
+    canBeStart: false,
+    canBeEnd: true,
+    maxOutgoing: 0
+  },
+  IntermediateCatchEvent: {
+    label: "Intermediate Catch Event",
+    icon: "Clock3",
+    category: "event",
+    defaultWidth: 36,
+    defaultHeight: 36,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    eventSemantics: "intermediateCatch",
+    canBeStart: false,
+    canBeEnd: false
+  },
+  IntermediateThrowEvent: {
+    label: "Intermediate Throw Event",
+    icon: "Send",
+    category: "event",
+    defaultWidth: 36,
+    defaultHeight: 36,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    eventSemantics: "intermediateThrow",
+    canBeStart: false,
+    canBeEnd: false
+  },
+  BoundaryEvent: {
+    label: "Boundary Event",
+    icon: "AlarmClock",
+    category: "event",
+    defaultWidth: 36,
+    defaultHeight: 36,
+    handlePolicy: "source",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    eventSemantics: "boundary",
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0
+  },
+  // ─── Tasks ───────────────────────────────────────────────────────────────────
+  Task: {
+    label: "Task",
+    icon: "CheckSquare",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  UserTask: {
+    label: "User Task",
+    icon: "UserRound",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  ServiceTask: {
+    label: "Service Task",
+    icon: "Cog",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  ScriptTask: {
+    label: "Script Task",
+    icon: "FileCode",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  ManualTask: {
+    label: "Manual Task",
+    icon: "Hand",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  BusinessRuleTask: {
+    label: "Business Rule Task",
+    icon: "Table2",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  ReceiveTask: {
+    label: "Receive Task",
+    icon: "Inbox",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  SendTask: {
+    label: "Send Task",
+    icon: "Send",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  CallActivity: {
+    label: "Call Activity",
+    icon: "ExternalLink",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  // ─── Gateways ────────────────────────────────────────────────────────────────
+  ExclusiveGateway: {
+    label: "Exclusive Gateway",
+    icon: "X",
+    category: "gateway",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  InclusiveGateway: {
+    label: "Inclusive Gateway",
+    icon: "Circle",
+    category: "gateway",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  ParallelGateway: {
+    label: "Parallel Gateway",
+    icon: "Plus",
+    category: "gateway",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  EventBasedGateway: {
+    label: "Event-Based Gateway",
+    icon: "Radio",
+    category: "gateway",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 1
+  },
+  ComplexGateway: {
+    label: "Complex Gateway",
+    icon: "Asterisk",
+    category: "gateway",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  // ─── Containers ───────────────────────────────────────────────────────────────
+  SubProcess: {
+    label: "Sub-Process",
+    icon: "PlusSquare",
+    category: "container",
+    defaultWidth: 350,
+    defaultHeight: 200,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: true,
+    acceptsBoundaryEvents: true,
+    supportsCollapse: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  Transaction: {
+    label: "Transaction",
+    icon: "Receipt",
+    category: "container",
+    defaultWidth: 350,
+    defaultHeight: 200,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: true,
+    acceptsBoundaryEvents: true,
+    supportsCollapse: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  EventSubProcess: {
+    label: "Event Sub-Process",
+    icon: "CircleDotDashed",
+    category: "container",
+    defaultWidth: 350,
+    defaultHeight: 200,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: true,
+    acceptsBoundaryEvents: false,
+    supportsCollapse: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  AdHocSubProcess: {
+    label: "Ad-Hoc Sub-Process",
+    icon: "Waves",
+    category: "container",
+    defaultWidth: 350,
+    defaultHeight: 200,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: true,
+    acceptsBoundaryEvents: true,
+    supportsCollapse: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  Pool: {
+    label: "Pool",
+    icon: "Rows3",
+    category: "container",
+    defaultWidth: 600,
+    defaultHeight: 200,
+    handlePolicy: "none",
+    orientation: "horizontal",
+    isContainer: true,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  Lane: {
+    label: "Lane",
+    icon: "PanelTop",
+    category: "container",
+    defaultWidth: 600,
+    defaultHeight: 120,
+    handlePolicy: "none",
+    orientation: "horizontal",
+    isContainer: true,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  // ─── Artifacts ────────────────────────────────────────────────────────────────
+  Annotation: {
+    label: "Text Annotation",
+    icon: "StickyNote",
+    category: "artifact",
+    defaultWidth: 100,
+    defaultHeight: 60,
+    handlePolicy: "none",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  Group: {
+    label: "Group",
+    icon: "Group",
+    category: "artifact",
+    defaultWidth: 300,
+    defaultHeight: 200,
+    handlePolicy: "none",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  // ─── Data (BPMN 2.0 §10.3) ───────────────────────────────────────────────────
+  DataObject: {
+    label: "Data Object",
+    icon: "File",
+    category: "data",
+    defaultWidth: 36,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  DataObjectReference: {
+    label: "Data Object Reference",
+    icon: "FileSymlink",
+    category: "data",
+    defaultWidth: 36,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  DataInput: {
+    label: "Data Input",
+    icon: "FileInput",
+    category: "data",
+    defaultWidth: 36,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0
+  },
+  DataOutput: {
+    label: "Data Output",
+    icon: "FileOutput",
+    category: "data",
+    defaultWidth: 36,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxOutgoing: 0
+  },
+  DataStore: {
+    label: "Data Store",
+    icon: "Database",
+    category: "data",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  DataStoreReference: {
+    label: "Data Store Reference",
+    icon: "DatabaseZap",
+    category: "data",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  // ─── Conversation (BPMN 2.0 §12) ─────────────────────────────────────────────
+  Conversation: {
+    label: "Conversation",
+    icon: "MessageCircle",
+    category: "conversation",
+    defaultWidth: 60,
+    defaultHeight: 52,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  SubConversation: {
+    label: "Sub-Conversation",
+    icon: "MessagesSquare",
+    category: "conversation",
+    defaultWidth: 60,
+    defaultHeight: 52,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: true,
+    acceptsBoundaryEvents: false,
+    supportsCollapse: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  CallConversation: {
+    label: "Call Conversation",
+    icon: "PhoneCall",
+    category: "conversation",
+    defaultWidth: 60,
+    defaultHeight: 52,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  // ─── Choreography (BPMN 2.0 §11) ─────────────────────────────────────────────
+  ChoreographyTask: {
+    label: "Choreography Task",
+    icon: "ArrowLeftRight",
+    category: "choreography",
+    defaultWidth: 120,
+    defaultHeight: 80,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  SubChoreography: {
+    label: "Sub-Choreography",
+    icon: "BoxSelect",
+    category: "choreography",
+    defaultWidth: 120,
+    defaultHeight: 80,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: true,
+    acceptsBoundaryEvents: false,
+    supportsCollapse: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  CallChoreography: {
+    label: "Call Choreography",
+    icon: "Phone",
+    category: "choreography",
+    defaultWidth: 120,
+    defaultHeight: 80,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  }
+};
 function getElementMeta(type) {
   return BPMN_ELEMENT_CATALOG[type];
 }
+var BPMN_RESIZABLE_ELEMENT_TYPES = [
+  "Task",
+  "UserTask",
+  "ServiceTask",
+  "ScriptTask",
+  "ManualTask",
+  "BusinessRuleTask",
+  "ReceiveTask",
+  "SendTask",
+  "CallActivity",
+  "SubProcess",
+  "Transaction",
+  "EventSubProcess",
+  "AdHocSubProcess",
+  "Pool",
+  "Lane",
+  "Annotation",
+  "Group",
+  "SubConversation",
+  "ChoreographyTask",
+  "SubChoreography",
+  "CallChoreography"
+];
+var BPMN_MIN_SIZE_OVERRIDES = {
+  Task: { minWidth: 80, minHeight: 48 },
+  UserTask: { minWidth: 80, minHeight: 48 },
+  ServiceTask: { minWidth: 80, minHeight: 48 },
+  ScriptTask: { minWidth: 80, minHeight: 48 },
+  ManualTask: { minWidth: 80, minHeight: 48 },
+  BusinessRuleTask: { minWidth: 80, minHeight: 48 },
+  ReceiveTask: { minWidth: 80, minHeight: 48 },
+  SendTask: { minWidth: 80, minHeight: 48 },
+  CallActivity: { minWidth: 80, minHeight: 48 },
+  SubProcess: { minWidth: 160, minHeight: 100 },
+  Transaction: { minWidth: 160, minHeight: 100 },
+  EventSubProcess: { minWidth: 160, minHeight: 100 },
+  AdHocSubProcess: { minWidth: 160, minHeight: 100 },
+  Pool: { minWidth: 240, minHeight: 120 },
+  Lane: { minWidth: 240, minHeight: 80 },
+  Annotation: { minWidth: 80, minHeight: 40 },
+  Group: { minWidth: 120, minHeight: 80 },
+  SubConversation: { minWidth: 60, minHeight: 52 },
+  ChoreographyTask: { minWidth: 100, minHeight: 70 },
+  SubChoreography: { minWidth: 100, minHeight: 70 },
+  CallChoreography: { minWidth: 100, minHeight: 70 }
+};
+var resizableTypes = new Set(BPMN_RESIZABLE_ELEMENT_TYPES);
 function isBpmnElementResizable(type) {
   return resizableTypes.has(type);
 }
@@ -32,624 +635,30 @@ function getBpmnElementSize(type) {
     resizable: meta.resizable ?? isBpmnElementResizable(type)
   };
 }
-var BPMN_ELEMENT_CATALOG, BPMN_RESIZABLE_ELEMENT_TYPES, BPMN_MIN_SIZE_OVERRIDES, resizableTypes;
-var init_catalog = __esm({
-  "src/elements/catalog.ts"() {
-    BPMN_ELEMENT_CATALOG = {
-      // ─── Events ──────────────────────────────────────────────────────────────────
-      StartEvent: {
-        label: "Start Event",
-        icon: "Circle",
-        category: "event",
-        defaultWidth: 36,
-        defaultHeight: 36,
-        handlePolicy: "source",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: false,
-        eventSemantics: "start",
-        canBeStart: true,
-        canBeEnd: false,
-        maxIncoming: 0,
-        maxOutgoing: 1
-      },
-      EndEvent: {
-        label: "End Event",
-        icon: "CircleDot",
-        category: "event",
-        defaultWidth: 36,
-        defaultHeight: 36,
-        handlePolicy: "target",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: false,
-        eventSemantics: "end",
-        canBeStart: false,
-        canBeEnd: true,
-        maxOutgoing: 0
-      },
-      IntermediateCatchEvent: {
-        label: "Intermediate Catch Event",
-        icon: "Clock3",
-        category: "event",
-        defaultWidth: 36,
-        defaultHeight: 36,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: false,
-        eventSemantics: "intermediateCatch",
-        canBeStart: false,
-        canBeEnd: false
-      },
-      IntermediateThrowEvent: {
-        label: "Intermediate Throw Event",
-        icon: "Send",
-        category: "event",
-        defaultWidth: 36,
-        defaultHeight: 36,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: false,
-        eventSemantics: "intermediateThrow",
-        canBeStart: false,
-        canBeEnd: false
-      },
-      BoundaryEvent: {
-        label: "Boundary Event",
-        icon: "AlarmClock",
-        category: "event",
-        defaultWidth: 36,
-        defaultHeight: 36,
-        handlePolicy: "source",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: false,
-        eventSemantics: "boundary",
-        canBeStart: false,
-        canBeEnd: false,
-        maxIncoming: 0
-      },
-      // ─── Tasks ───────────────────────────────────────────────────────────────────
-      Task: {
-        label: "Task",
-        icon: "CheckSquare",
-        category: "task",
-        defaultWidth: 120,
-        defaultHeight: 60,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: true,
-        supportsMarkers: true,
-        canBeStart: false,
-        canBeEnd: false
-      },
-      UserTask: {
-        label: "User Task",
-        icon: "UserRound",
-        category: "task",
-        defaultWidth: 120,
-        defaultHeight: 60,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: true,
-        supportsMarkers: true,
-        canBeStart: false,
-        canBeEnd: false
-      },
-      ServiceTask: {
-        label: "Service Task",
-        icon: "Cog",
-        category: "task",
-        defaultWidth: 120,
-        defaultHeight: 60,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: true,
-        supportsMarkers: true,
-        canBeStart: false,
-        canBeEnd: false
-      },
-      ScriptTask: {
-        label: "Script Task",
-        icon: "FileCode",
-        category: "task",
-        defaultWidth: 120,
-        defaultHeight: 60,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: true,
-        supportsMarkers: true,
-        canBeStart: false,
-        canBeEnd: false
-      },
-      ManualTask: {
-        label: "Manual Task",
-        icon: "Hand",
-        category: "task",
-        defaultWidth: 120,
-        defaultHeight: 60,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: true,
-        supportsMarkers: true,
-        canBeStart: false,
-        canBeEnd: false
-      },
-      BusinessRuleTask: {
-        label: "Business Rule Task",
-        icon: "Table2",
-        category: "task",
-        defaultWidth: 120,
-        defaultHeight: 60,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: true,
-        supportsMarkers: true,
-        canBeStart: false,
-        canBeEnd: false
-      },
-      ReceiveTask: {
-        label: "Receive Task",
-        icon: "Inbox",
-        category: "task",
-        defaultWidth: 120,
-        defaultHeight: 60,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: true,
-        supportsMarkers: true,
-        canBeStart: false,
-        canBeEnd: false
-      },
-      SendTask: {
-        label: "Send Task",
-        icon: "Send",
-        category: "task",
-        defaultWidth: 120,
-        defaultHeight: 60,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: true,
-        supportsMarkers: true,
-        canBeStart: false,
-        canBeEnd: false
-      },
-      CallActivity: {
-        label: "Call Activity",
-        icon: "ExternalLink",
-        category: "task",
-        defaultWidth: 120,
-        defaultHeight: 60,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: true,
-        supportsMarkers: true,
-        canBeStart: false,
-        canBeEnd: false
-      },
-      // ─── Gateways ────────────────────────────────────────────────────────────────
-      ExclusiveGateway: {
-        label: "Exclusive Gateway",
-        icon: "X",
-        category: "gateway",
-        defaultWidth: 50,
-        defaultHeight: 50,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: false,
-        canBeStart: false,
-        canBeEnd: false
-      },
-      InclusiveGateway: {
-        label: "Inclusive Gateway",
-        icon: "Circle",
-        category: "gateway",
-        defaultWidth: 50,
-        defaultHeight: 50,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: false,
-        canBeStart: false,
-        canBeEnd: false
-      },
-      ParallelGateway: {
-        label: "Parallel Gateway",
-        icon: "Plus",
-        category: "gateway",
-        defaultWidth: 50,
-        defaultHeight: 50,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: false,
-        canBeStart: false,
-        canBeEnd: false
-      },
-      EventBasedGateway: {
-        label: "Event-Based Gateway",
-        icon: "Radio",
-        category: "gateway",
-        defaultWidth: 50,
-        defaultHeight: 50,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: false,
-        canBeStart: false,
-        canBeEnd: false,
-        maxIncoming: 1
-      },
-      ComplexGateway: {
-        label: "Complex Gateway",
-        icon: "Asterisk",
-        category: "gateway",
-        defaultWidth: 50,
-        defaultHeight: 50,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: false,
-        canBeStart: false,
-        canBeEnd: false
-      },
-      // ─── Containers ───────────────────────────────────────────────────────────────
-      SubProcess: {
-        label: "Sub-Process",
-        icon: "PlusSquare",
-        category: "container",
-        defaultWidth: 350,
-        defaultHeight: 200,
-        handlePolicy: "all",
-        orientation: "horizontal",
-        isContainer: true,
-        acceptsBoundaryEvents: true,
-        supportsCollapse: true,
-        supportsMarkers: true,
-        canBeStart: false,
-        canBeEnd: false
-      },
-      Transaction: {
-        label: "Transaction",
-        icon: "Receipt",
-        category: "container",
-        defaultWidth: 350,
-        defaultHeight: 200,
-        handlePolicy: "all",
-        orientation: "horizontal",
-        isContainer: true,
-        acceptsBoundaryEvents: true,
-        supportsCollapse: true,
-        supportsMarkers: true,
-        canBeStart: false,
-        canBeEnd: false
-      },
-      EventSubProcess: {
-        label: "Event Sub-Process",
-        icon: "CircleDotDashed",
-        category: "container",
-        defaultWidth: 350,
-        defaultHeight: 200,
-        handlePolicy: "all",
-        orientation: "horizontal",
-        isContainer: true,
-        acceptsBoundaryEvents: false,
-        supportsCollapse: true,
-        supportsMarkers: true,
-        canBeStart: false,
-        canBeEnd: false
-      },
-      AdHocSubProcess: {
-        label: "Ad-Hoc Sub-Process",
-        icon: "Waves",
-        category: "container",
-        defaultWidth: 350,
-        defaultHeight: 200,
-        handlePolicy: "all",
-        orientation: "horizontal",
-        isContainer: true,
-        acceptsBoundaryEvents: true,
-        supportsCollapse: true,
-        supportsMarkers: true,
-        canBeStart: false,
-        canBeEnd: false
-      },
-      Pool: {
-        label: "Pool",
-        icon: "Rows3",
-        category: "container",
-        defaultWidth: 600,
-        defaultHeight: 200,
-        handlePolicy: "none",
-        orientation: "horizontal",
-        isContainer: true,
-        acceptsBoundaryEvents: false,
-        canBeStart: false,
-        canBeEnd: false,
-        maxIncoming: 0,
-        maxOutgoing: 0
-      },
-      Lane: {
-        label: "Lane",
-        icon: "PanelTop",
-        category: "container",
-        defaultWidth: 600,
-        defaultHeight: 120,
-        handlePolicy: "none",
-        orientation: "horizontal",
-        isContainer: true,
-        acceptsBoundaryEvents: false,
-        canBeStart: false,
-        canBeEnd: false,
-        maxIncoming: 0,
-        maxOutgoing: 0
-      },
-      // ─── Artifacts ────────────────────────────────────────────────────────────────
-      Annotation: {
-        label: "Text Annotation",
-        icon: "StickyNote",
-        category: "artifact",
-        defaultWidth: 100,
-        defaultHeight: 60,
-        handlePolicy: "none",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: false,
-        canBeStart: false,
-        canBeEnd: false,
-        maxIncoming: 0,
-        maxOutgoing: 0
-      },
-      Group: {
-        label: "Group",
-        icon: "Group",
-        category: "artifact",
-        defaultWidth: 300,
-        defaultHeight: 200,
-        handlePolicy: "none",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: false,
-        canBeStart: false,
-        canBeEnd: false,
-        maxIncoming: 0,
-        maxOutgoing: 0
-      },
-      // ─── Data (BPMN 2.0 §10.3) ───────────────────────────────────────────────────
-      DataObject: {
-        label: "Data Object",
-        icon: "File",
-        category: "data",
-        defaultWidth: 36,
-        defaultHeight: 50,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: false,
-        canBeStart: false,
-        canBeEnd: false,
-        maxIncoming: 0,
-        maxOutgoing: 0
-      },
-      DataObjectReference: {
-        label: "Data Object Reference",
-        icon: "FileSymlink",
-        category: "data",
-        defaultWidth: 36,
-        defaultHeight: 50,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: false,
-        canBeStart: false,
-        canBeEnd: false,
-        maxIncoming: 0,
-        maxOutgoing: 0
-      },
-      DataInput: {
-        label: "Data Input",
-        icon: "FileInput",
-        category: "data",
-        defaultWidth: 36,
-        defaultHeight: 50,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: false,
-        canBeStart: false,
-        canBeEnd: false,
-        maxIncoming: 0
-      },
-      DataOutput: {
-        label: "Data Output",
-        icon: "FileOutput",
-        category: "data",
-        defaultWidth: 36,
-        defaultHeight: 50,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: false,
-        canBeStart: false,
-        canBeEnd: false,
-        maxOutgoing: 0
-      },
-      DataStore: {
-        label: "Data Store",
-        icon: "Database",
-        category: "data",
-        defaultWidth: 50,
-        defaultHeight: 50,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: false,
-        canBeStart: false,
-        canBeEnd: false,
-        maxIncoming: 0,
-        maxOutgoing: 0
-      },
-      DataStoreReference: {
-        label: "Data Store Reference",
-        icon: "DatabaseZap",
-        category: "data",
-        defaultWidth: 50,
-        defaultHeight: 50,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: false,
-        canBeStart: false,
-        canBeEnd: false,
-        maxIncoming: 0,
-        maxOutgoing: 0
-      },
-      // ─── Conversation (BPMN 2.0 §12) ─────────────────────────────────────────────
-      Conversation: {
-        label: "Conversation",
-        icon: "MessageCircle",
-        category: "conversation",
-        defaultWidth: 60,
-        defaultHeight: 52,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: false,
-        canBeStart: false,
-        canBeEnd: false
-      },
-      SubConversation: {
-        label: "Sub-Conversation",
-        icon: "MessagesSquare",
-        category: "conversation",
-        defaultWidth: 60,
-        defaultHeight: 52,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: true,
-        acceptsBoundaryEvents: false,
-        supportsCollapse: true,
-        canBeStart: false,
-        canBeEnd: false
-      },
-      CallConversation: {
-        label: "Call Conversation",
-        icon: "PhoneCall",
-        category: "conversation",
-        defaultWidth: 60,
-        defaultHeight: 52,
-        handlePolicy: "all",
-        orientation: "free",
-        isContainer: false,
-        acceptsBoundaryEvents: false,
-        canBeStart: false,
-        canBeEnd: false
-      },
-      // ─── Choreography (BPMN 2.0 §11) ─────────────────────────────────────────────
-      ChoreographyTask: {
-        label: "Choreography Task",
-        icon: "ArrowLeftRight",
-        category: "choreography",
-        defaultWidth: 120,
-        defaultHeight: 80,
-        handlePolicy: "all",
-        orientation: "horizontal",
-        isContainer: false,
-        acceptsBoundaryEvents: false,
-        canBeStart: false,
-        canBeEnd: false
-      },
-      SubChoreography: {
-        label: "Sub-Choreography",
-        icon: "BoxSelect",
-        category: "choreography",
-        defaultWidth: 120,
-        defaultHeight: 80,
-        handlePolicy: "all",
-        orientation: "horizontal",
-        isContainer: true,
-        acceptsBoundaryEvents: false,
-        supportsCollapse: true,
-        canBeStart: false,
-        canBeEnd: false
-      },
-      CallChoreography: {
-        label: "Call Choreography",
-        icon: "Phone",
-        category: "choreography",
-        defaultWidth: 120,
-        defaultHeight: 80,
-        handlePolicy: "all",
-        orientation: "horizontal",
-        isContainer: false,
-        acceptsBoundaryEvents: false,
-        canBeStart: false,
-        canBeEnd: false
-      }
-    };
-    BPMN_RESIZABLE_ELEMENT_TYPES = [
-      "Task",
-      "UserTask",
-      "ServiceTask",
-      "ScriptTask",
-      "ManualTask",
-      "BusinessRuleTask",
-      "ReceiveTask",
-      "SendTask",
-      "CallActivity",
-      "SubProcess",
-      "Transaction",
-      "EventSubProcess",
-      "AdHocSubProcess",
-      "Pool",
-      "Lane",
-      "Annotation",
-      "Group",
-      "SubConversation",
-      "ChoreographyTask",
-      "SubChoreography",
-      "CallChoreography"
-    ];
-    BPMN_MIN_SIZE_OVERRIDES = {
-      Task: { minWidth: 80, minHeight: 48 },
-      UserTask: { minWidth: 80, minHeight: 48 },
-      ServiceTask: { minWidth: 80, minHeight: 48 },
-      ScriptTask: { minWidth: 80, minHeight: 48 },
-      ManualTask: { minWidth: 80, minHeight: 48 },
-      BusinessRuleTask: { minWidth: 80, minHeight: 48 },
-      ReceiveTask: { minWidth: 80, minHeight: 48 },
-      SendTask: { minWidth: 80, minHeight: 48 },
-      CallActivity: { minWidth: 80, minHeight: 48 },
-      SubProcess: { minWidth: 160, minHeight: 100 },
-      Transaction: { minWidth: 160, minHeight: 100 },
-      EventSubProcess: { minWidth: 160, minHeight: 100 },
-      AdHocSubProcess: { minWidth: 160, minHeight: 100 },
-      Pool: { minWidth: 240, minHeight: 120 },
-      Lane: { minWidth: 240, minHeight: 80 },
-      Annotation: { minWidth: 80, minHeight: 40 },
-      Group: { minWidth: 120, minHeight: 80 },
-      SubConversation: { minWidth: 60, minHeight: 52 },
-      ChoreographyTask: { minWidth: 100, minHeight: 70 },
-      SubChoreography: { minWidth: 100, minHeight: 70 },
-      CallChoreography: { minWidth: 100, minHeight: 70 }
-    };
-    resizableTypes = new Set(BPMN_RESIZABLE_ELEMENT_TYPES);
-  }
-});
 
 // src/elements/guards.ts
+var GATEWAY_TYPES = /* @__PURE__ */ new Set([
+  "ExclusiveGateway",
+  "InclusiveGateway",
+  "ParallelGateway",
+  "EventBasedGateway",
+  "ComplexGateway"
+]);
+var EVENT_TYPES = /* @__PURE__ */ new Set([
+  "StartEvent",
+  "EndEvent",
+  "IntermediateCatchEvent",
+  "IntermediateThrowEvent",
+  "BoundaryEvent"
+]);
+var DATA_TYPES = /* @__PURE__ */ new Set([
+  "DataObject",
+  "DataObjectReference",
+  "DataInput",
+  "DataOutput",
+  "DataStore",
+  "DataStoreReference"
+]);
 function isGatewayType(type) {
   return GATEWAY_TYPES.has(type);
 }
@@ -665,34 +674,45 @@ function acceptsBoundaryEvents(type) {
 function getHandlePolicy(type) {
   return BPMN_ELEMENT_CATALOG[type].handlePolicy;
 }
-var GATEWAY_TYPES, EVENT_TYPES, DATA_TYPES;
-var init_guards = __esm({
-  "src/elements/guards.ts"() {
-    init_catalog();
-    GATEWAY_TYPES = /* @__PURE__ */ new Set([
-      "ExclusiveGateway",
-      "InclusiveGateway",
-      "ParallelGateway",
-      "EventBasedGateway",
-      "ComplexGateway"
-    ]);
-    EVENT_TYPES = /* @__PURE__ */ new Set([
-      "StartEvent",
-      "EndEvent",
-      "IntermediateCatchEvent",
-      "IntermediateThrowEvent",
-      "BoundaryEvent"
-    ]);
-    DATA_TYPES = /* @__PURE__ */ new Set([
-      "DataObject",
-      "DataObjectReference",
-      "DataInput",
-      "DataOutput",
-      "DataStore",
-      "DataStoreReference"
-    ]);
+
+// src/modeling/index.ts
+var BPMN_EDGE_CONNECTION_RULES = {
+  sequenceFlow: {
+    edgeType: "sequenceFlow",
+    sourceCategories: ["flowNode"],
+    targetCategories: ["flowNode"],
+    allowSameParent: true,
+    allowDifferentParent: false
+  },
+  messageFlow: {
+    edgeType: "messageFlow",
+    sourceCategories: ["flowNode"],
+    targetCategories: ["flowNode"],
+    allowSameParent: false,
+    allowDifferentParent: true
+  },
+  association: {
+    edgeType: "association",
+    sourceCategories: ["flowNode", "artifact", "data"],
+    targetCategories: ["flowNode", "artifact", "data"],
+    allowSameParent: true,
+    allowDifferentParent: true
+  },
+  dataAssociation: {
+    edgeType: "dataAssociation",
+    sourceCategories: ["flowNode", "data"],
+    targetCategories: ["flowNode", "data"],
+    allowSameParent: true,
+    allowDifferentParent: true
+  },
+  conversationLink: {
+    edgeType: "conversationLink",
+    sourceCategories: ["conversation", "flowNode"],
+    targetCategories: ["conversation", "flowNode"],
+    allowSameParent: true,
+    allowDifferentParent: true
   }
-});
+};
 function inferBpmnEdgeType(state, sourceId, targetId) {
   const source = diagramsCore.getNode(state, sourceId);
   const target = diagramsCore.getNode(state, targetId);
@@ -797,109 +817,82 @@ function validateEdgeCardinality(state, edgeType, source, target) {
   }
   return true;
 }
-var BPMN_EDGE_CONNECTION_RULES, bpmnConnectionValidators;
-var init_modeling = __esm({
-  "src/modeling/index.ts"() {
-    init_catalog();
-    init_guards();
-    init_catalog();
-    BPMN_EDGE_CONNECTION_RULES = {
-      sequenceFlow: {
-        edgeType: "sequenceFlow",
-        sourceCategories: ["flowNode"],
-        targetCategories: ["flowNode"],
-        allowSameParent: true,
-        allowDifferentParent: false
-      },
-      messageFlow: {
-        edgeType: "messageFlow",
-        sourceCategories: ["flowNode"],
-        targetCategories: ["flowNode"],
-        allowSameParent: false,
-        allowDifferentParent: true
-      },
-      association: {
-        edgeType: "association",
-        sourceCategories: ["flowNode", "artifact", "data"],
-        targetCategories: ["flowNode", "artifact", "data"],
-        allowSameParent: true,
-        allowDifferentParent: true
-      },
-      dataAssociation: {
-        edgeType: "dataAssociation",
-        sourceCategories: ["flowNode", "data"],
-        targetCategories: ["flowNode", "data"],
-        allowSameParent: true,
-        allowDifferentParent: true
-      },
-      conversationLink: {
-        edgeType: "conversationLink",
-        sourceCategories: ["conversation", "flowNode"],
-        targetCategories: ["conversation", "flowNode"],
-        allowSameParent: true,
-        allowDifferentParent: true
+var bpmnConnectionValidators = [
+  ({ state, source, target }) => {
+    if (source.id === target.id) return "BPMN self-connections are not allowed.";
+    const edgeType = inferBpmnEdgeType(state, source.id, target.id);
+    if (getHandlePolicy(source.data.elementType) === "none" || getHandlePolicy(target.data.elementType) === "none") {
+      return "Elements without BPMN connection handles cannot be directly connected.";
+    }
+    if (edgeType === "sequenceFlow") {
+      return validateBpmnConnectionForEdgeType(state, edgeType, source, target);
+    }
+    return validateBpmnConnectionForEdgeType(state, edgeType, source, target);
+  }
+];
+diagramsCore.createModelingRules({
+  connect: [
+    ({ state, source, target }) => {
+      if (!source || !target) return false;
+      for (const validator of bpmnConnectionValidators) {
+        const result = validator({
+          state,
+          source,
+          target,
+          existingEdges: state.edges
+        });
+        if (result !== true) return result;
       }
-    };
-    bpmnConnectionValidators = [
-      ({ state, source, target }) => {
-        if (source.id === target.id) return "BPMN self-connections are not allowed.";
-        const edgeType = inferBpmnEdgeType(state, source.id, target.id);
-        if (getHandlePolicy(source.data.elementType) === "none" || getHandlePolicy(target.data.elementType) === "none") {
-          return "Elements without BPMN connection handles cannot be directly connected.";
-        }
-        if (edgeType === "sequenceFlow") {
-          return validateBpmnConnectionForEdgeType(state, edgeType, source, target);
-        }
-        return validateBpmnConnectionForEdgeType(state, edgeType, source, target);
+      return true;
+    }
+  ],
+  drop: [
+    ({ node, parent }) => {
+      if (!node || !parent) return true;
+      if (node.data.elementType === "BoundaryEvent") {
+        return acceptsBoundaryEvents(parent.data.elementType) ? true : "Boundary events can only be attached to tasks or subprocesses.";
       }
-    ];
-    diagramsCore.createModelingRules({
-      connect: [
-        ({ state, source, target }) => {
-          if (!source || !target) return false;
-          for (const validator of bpmnConnectionValidators) {
-            const result = validator({
-              state,
-              source,
-              target,
-              existingEdges: state.edges
-            });
-            if (result !== true) return result;
-          }
-          return true;
-        }
-      ],
-      drop: [
-        ({ node, parent }) => {
-          if (!node || !parent) return true;
-          if (node.data.elementType === "BoundaryEvent") {
-            return acceptsBoundaryEvents(parent.data.elementType) ? true : "Boundary events can only be attached to tasks or subprocesses.";
-          }
-          return canContainBpmnElement(parent.data.elementType, node.data.elementType);
-        }
-      ],
-      reparent: [
-        ({ node, parent }) => {
-          if (!node || !parent) return true;
-          if (node.data.elementType === "BoundaryEvent") {
-            return acceptsBoundaryEvents(parent.data.elementType) ? true : "Boundary events can only be reparented to tasks or subprocesses.";
-          }
-          return canContainBpmnElement(parent?.data.elementType, node.data.elementType);
-        }
-      ],
-      delete: [() => true],
-      resize: [
-        ({ node }) => !node || isBpmnElementResizable(node.data.elementType) ? true : `${node.data.elementType} is not resizable in BPMN.`
-      ]
-    });
-  }
-});
-
-// src/layout/elk.ts
-var elk_exports = {};
-__export(elk_exports, {
-  bpmnElkLayout: () => bpmnElkLayout
+      return canContainBpmnElement(parent.data.elementType, node.data.elementType);
+    }
+  ],
+  reparent: [
+    ({ node, parent }) => {
+      if (!node || !parent) return true;
+      if (node.data.elementType === "BoundaryEvent") {
+        return acceptsBoundaryEvents(parent.data.elementType) ? true : "Boundary events can only be reparented to tasks or subprocesses.";
+      }
+      return canContainBpmnElement(parent?.data.elementType, node.data.elementType);
+    }
+  ],
+  delete: [() => true],
+  resize: [
+    ({ node }) => !node || isBpmnElementResizable(node.data.elementType) ? true : `${node.data.elementType} is not resizable in BPMN.`
+  ]
 });
+var BPMN_CONTAINER_TYPES = /* @__PURE__ */ new Set([
+  "Pool",
+  "Lane",
+  "SubProcess",
+  "Transaction",
+  "EventSubProcess",
+  "AdHocSubProcess"
+]);
+var CONTAINER_MIN_SIZE = {
+  Pool: { w: 720, h: 200 },
+  Lane: { w: 600, h: 160 },
+  SubProcess: { w: 240, h: 140 },
+  Transaction: { w: 240, h: 140 },
+  EventSubProcess: { w: 240, h: 140 },
+  AdHocSubProcess: { w: 240, h: 140 }
+};
+var CONTAINER_PADDING = {
+  Pool: "[top=30,left=60,bottom=30,right=50]",
+  Lane: "[top=40,left=70,bottom=40,right=50]",
+  SubProcess: "[top=30,left=40,bottom=30,right=40]",
+  Transaction: "[top=30,left=40,bottom=30,right=40]",
+  EventSubProcess: "[top=30,left=40,bottom=30,right=40]",
+  AdHocSubProcess: "[top=30,left=40,bottom=30,right=40]"
+};
 async function bpmnElkLayout(nodes, edges) {
   const poolsWithLanes = /* @__PURE__ */ new Set();
   for (const node of nodes) {
@@ -1032,40 +1025,6 @@ async function bpmnElkLayout(nodes, edges) {
   });
   return { nodes: updatedNodes, edges: updatedEdges };
 }
-var BPMN_CONTAINER_TYPES, CONTAINER_MIN_SIZE, CONTAINER_PADDING;
-var init_elk = __esm({
-  "src/layout/elk.ts"() {
-    init_modeling();
-    BPMN_CONTAINER_TYPES = /* @__PURE__ */ new Set([
-      "Pool",
-      "Lane",
-      "SubProcess",
-      "Transaction",
-      "EventSubProcess",
-      "AdHocSubProcess"
-    ]);
-    CONTAINER_MIN_SIZE = {
-      Pool: { w: 720, h: 200 },
-      Lane: { w: 600, h: 160 },
-      SubProcess: { w: 240, h: 140 },
-      Transaction: { w: 240, h: 140 },
-      EventSubProcess: { w: 240, h: 140 },
-      AdHocSubProcess: { w: 240, h: 140 }
-    };
-    CONTAINER_PADDING = {
-      Pool: "[top=30,left=60,bottom=30,right=50]",
-      Lane: "[top=40,left=70,bottom=40,right=50]",
-      SubProcess: "[top=30,left=40,bottom=30,right=40]",
-      Transaction: "[top=30,left=40,bottom=30,right=40]",
-      EventSubProcess: "[top=30,left=40,bottom=30,right=40]",
-      AdHocSubProcess: "[top=30,left=40,bottom=30,right=40]"
-    };
-  }
-});
-
-// src/layout/index.ts
-init_modeling();
-init_elk();
 
 // src/layout/bpmn-layout-graph.ts
 var LAYOUT_CONTAINER_TYPES = /* @__PURE__ */ new Set([
@@ -1084,15 +1043,21 @@ var LAYOUT_GATEWAY_TYPES = /* @__PURE__ */ new Set([
   "ComplexGateway"
 ]);
 function detectBackEdges(nodeIds, seqEdges) {
+  const sortedIds = [...nodeIds].sort();
   const backEdgeIds = /* @__PURE__ */ new Set();
   const state = /* @__PURE__ */ new Map();
-  for (const id of nodeIds) state.set(id, 0);
+  for (const id of sortedIds) state.set(id, 0);
   const adj = /* @__PURE__ */ new Map();
-  for (const id of nodeIds) adj.set(id, []);
+  for (const id of sortedIds) adj.set(id, []);
   for (const e of seqEdges) {
     adj.get(e.source)?.push({ target: e.target, edgeId: e.id });
   }
-  for (const startId of nodeIds) {
+  for (const list of adj.values()) {
+    list.sort(
+      (a, b) => a.target < b.target ? -1 : a.target > b.target ? 1 : a.edgeId < b.edgeId ? -1 : a.edgeId > b.edgeId ? 1 : 0
+    );
+  }
+  for (const startId of sortedIds) {
     if (state.get(startId) !== 0) continue;
     const stack = [{ id: startId, idx: 0 }];
     state.set(startId, 1);
@@ -1169,9 +1134,7 @@ function detectGatewayPairs(nodes, forwardEdges) {
   }
   const order = topologicalSort(nodeIds, forwardEdges);
   const topoPos = new Map(order.map((id, i) => [id, i]));
-  const splits = nodes.filter(
-    (n) => LAYOUT_GATEWAY_TYPES.has(n.data.elementType) && (succs.get(n.id)?.length ?? 0) > 1
-  );
+  const splits = nodes.filter((n) => (succs.get(n.id)?.length ?? 0) > 1);
   for (const split of splits) {
     const branches = succs.get(split.id) ?? [];
     if (branches.length < 2) continue;
@@ -1223,12 +1186,18 @@ function buildHandleMap(edges) {
   }
   return map;
 }
+function branchPullBias(nodeIds, nodeBias) {
+  if (!nodeBias) return null;
+  let sum = 0;
+  for (const id of nodeIds) sum += nodeBias.get(id) ?? 0;
+  if (sum === 0) return null;
+  return sum > 0 ? 1 : -1;
+}
 function pickMainBranch(branchData) {
   if (branchData.length === 0) return void 0;
   return [...branchData].sort((a, b) => {
-    const aRight = a.bias === 0 ? 1 : 0;
-    const bRight = b.bias === 0 ? 1 : 0;
-    if (aRight !== bRight) return bRight - aRight;
+    const rank = (branch) => branch.bias === 0 ? 2 : branch.bias === null ? 1 : 0;
+    if (rank(a) !== rank(b)) return rank(b) - rank(a);
     if (a.nodeIds.length !== b.nodeIds.length) return b.nodeIds.length - a.nodeIds.length;
     return a.start.localeCompare(b.start);
   })[0]?.start;
@@ -1269,7 +1238,7 @@ function assignBranchRowsAroundMain(branchData, splitRow) {
   }
   return assigned;
 }
-function assignRows(nodes, forwardEdges, columns, gatewayPairs) {
+function assignRows(nodes, forwardEdges, columns, gatewayPairs, nodeBias) {
   const rows = new Map(nodes.map((n) => [n.id, 0]));
   const succs = new Map(nodes.map((n) => [n.id, []]));
   for (const e of forwardEdges) {
@@ -1277,7 +1246,7 @@ function assignRows(nodes, forwardEdges, columns, gatewayPairs) {
   }
   const handleMap = buildHandleMap(forwardEdges);
   const sortedPairs = [...gatewayPairs.entries()].sort(
-    (a, b) => (columns.get(b[0]) ?? 0) - (columns.get(a[0]) ?? 0)
+    (a, b) => (columns.get(a[0]) ?? 0) - (columns.get(b[0]) ?? 0)
   );
   for (const [splitId, mergeId] of sortedPairs) {
     const branches = succs.get(splitId) ?? [];
@@ -1297,11 +1266,14 @@ function assignRows(nodes, forwardEdges, columns, gatewayPairs) {
       return result;
     };
     const splitHandles = handleMap.get(splitId);
-    const branchData = branches.map((start) => ({
-      start,
-      nodeIds: getBranchNodes(start),
-      bias: handleToRowBias(splitHandles?.get(start) ?? null)
-    }));
+    const branchData = branches.map((start) => {
+      const nodeIds = getBranchNodes(start);
+      return {
+        start,
+        nodeIds,
+        bias: handleToRowBias(splitHandles?.get(start) ?? null) ?? branchPullBias(nodeIds, nodeBias)
+      };
+    });
     const assigned = assignBranchRowsAroundMain(branchData, splitRow);
     for (const b of branchData) {
       const row = assigned.get(b.start) ?? splitRow;
@@ -1313,7 +1285,7 @@ function assignRows(nodes, forwardEdges, columns, gatewayPairs) {
   }
   const pairedSplits = new Set(gatewayPairs.keys());
   const unpairedSplits = nodes.filter(
-    (n) => LAYOUT_GATEWAY_TYPES.has(n.data.elementType) && !pairedSplits.has(n.id) && (succs.get(n.id)?.length ?? 0) > 1
+    (n) => !pairedSplits.has(n.id) && (succs.get(n.id)?.length ?? 0) > 1
   );
   for (const split of unpairedSplits) {
     const branches = succs.get(split.id) ?? [];
@@ -1333,11 +1305,14 @@ function assignRows(nodes, forwardEdges, columns, gatewayPairs) {
       return result;
     };
     const splitHandles2 = handleMap.get(split.id);
-    const branchData = branches.map((start) => ({
-      start,
-      nodeIds: getAllReachable(start),
-      bias: handleToRowBias(splitHandles2?.get(start) ?? null)
-    }));
+    const branchData = branches.map((start) => {
+      const nodeIds = getAllReachable(start);
+      return {
+        start,
+        nodeIds,
+        bias: handleToRowBias(splitHandles2?.get(start) ?? null) ?? branchPullBias(nodeIds, nodeBias)
+      };
+    });
     const assigned2 = assignBranchRowsAroundMain(branchData, splitRow);
     for (const b of branchData) {
       const row = assigned2.get(b.start) ?? splitRow;
@@ -1390,6 +1365,17 @@ var LAYOUT_TASK_TYPES = /* @__PURE__ */ new Set([
 ]);
 var TASK_LAYOUT_MIN_W = 130;
 var TASK_LAYOUT_MIN_H = 80;
+var SUBPROCESS_LAYOUT_MIN_W = 160;
+var SUBPROCESS_LAYOUT_MIN_H = 80;
+function layoutMinSize(node) {
+  if (LAYOUT_TASK_TYPES.has(node.data.elementType)) {
+    return { w: TASK_LAYOUT_MIN_W, h: TASK_LAYOUT_MIN_H };
+  }
+  if (COLLAPSED_SUBPROCESS_TYPES.has(node.data.elementType) && !node.data.isExpanded) {
+    return { w: SUBPROCESS_LAYOUT_MIN_W, h: SUBPROCESS_LAYOUT_MIN_H };
+  }
+  return null;
+}
 function nW(node) {
   return node.width ?? node.measured?.width ?? 120;
 }
@@ -1397,18 +1383,68 @@ function nH(node) {
   return node.height ?? node.measured?.height ?? 60;
 }
 function layoutW(node) {
-  return LAYOUT_TASK_TYPES.has(node.data.elementType) ? Math.max(nW(node), TASK_LAYOUT_MIN_W) : nW(node);
+  const min = layoutMinSize(node);
+  return min ? Math.max(nW(node), min.w) : nW(node);
 }
 function layoutH(node) {
-  return LAYOUT_TASK_TYPES.has(node.data.elementType) ? Math.max(nH(node), TASK_LAYOUT_MIN_H) : nH(node);
+  const min = layoutMinSize(node);
+  return min ? Math.max(nH(node), min.h) : nH(node);
+}
+var LABEL_RESERVE_TYPES = /* @__PURE__ */ new Set([
+  ...LAYOUT_GATEWAY_TYPES,
+  "StartEvent",
+  "EndEvent",
+  "IntermediateCatchEvent",
+  "IntermediateThrowEvent"
+]);
+var LABEL_CHAR_W = 6.5;
+var LABEL_RESERVE_MAX = 150;
+function columnW(node) {
+  const base = layoutW(node);
+  if (!LABEL_RESERVE_TYPES.has(node.data.elementType)) return base;
+  const label = typeof node.data.label === "string" ? node.data.label : "";
+  if (!label) return base;
+  const reserve = Math.min(Math.ceil(label.length * LABEL_CHAR_W), LABEL_RESERVE_MAX);
+  return Math.max(base, reserve);
 }
 function applyLayoutMinSize(node) {
-  if (!LAYOUT_TASK_TYPES.has(node.data.elementType)) return node;
+  if (!layoutMinSize(node)) return node;
   const w = layoutW(node);
   const h = layoutH(node);
   if (w === nW(node) && h === nH(node)) return node;
   return { ...node, width: w, height: h, measured: { width: w, height: h } };
 }
+function computeRowMetrics(contextNodes, rows, includeRowZero) {
+  const vals = contextNodes.map((n) => rows.get(n.id) ?? 0);
+  const base = includeRowZero ? [0, ...vals] : vals;
+  const minRow = Math.min(...base);
+  const maxRow = Math.max(...base);
+  const rowH = /* @__PURE__ */ new Map();
+  for (let r = minRow; r <= maxRow; r++) rowH.set(r, ROW_HEIGHT);
+  for (const node of contextNodes) {
+    const r = rows.get(node.id) ?? 0;
+    rowH.set(r, Math.max(rowH.get(r) ?? ROW_HEIGHT, layoutH(node)));
+  }
+  const rowY = /* @__PURE__ */ new Map();
+  let y = 0;
+  for (let r = minRow; r <= maxRow; r++) {
+    rowY.set(r, y);
+    y += (rowH.get(r) ?? ROW_HEIGHT) + ROW_GAP;
+  }
+  return { minRow, maxRow, rowH, rowY, contentH: y - ROW_GAP };
+}
+function reanchorBoundaryEdges(edges, boundaryEvents, contentIds) {
+  if (boundaryEvents.length === 0) return edges;
+  const hostByBoundaryId = /* @__PURE__ */ new Map();
+  for (const be of boundaryEvents) {
+    if (be.data.attachedToRef) hostByBoundaryId.set(be.id, be.data.attachedToRef);
+  }
+  if (hostByBoundaryId.size === 0) return edges;
+  return edges.map((edge) => {
+    const host = hostByBoundaryId.get(edge.source);
+    return host && contentIds.has(host) ? { ...edge, source: host, sourceHandle: "source-bottom" } : edge;
+  });
+}
 var BOUNDARY_SPACING = 10;
 function repositionBoundaryEvents(boundaryEvents, positionedContent) {
   if (boundaryEvents.length === 0) return [];
@@ -1465,7 +1501,8 @@ function layoutSubProcess(children, edges) {
     };
   }
   const contentIds = new Set(mainChildren.map((n) => n.id));
-  const seqEdges = extractSeqEdges(edges, contentIds);
+  const graphEdges = reanchorBoundaryEdges(edges, boundaryEvents, contentIds);
+  const seqEdges = extractSeqEdges(graphEdges, contentIds);
   const backIds = detectBackEdges([...contentIds], seqEdges);
   const fwdEdges = seqEdges.filter((e) => !backIds.has(e.id));
   const columns = assignColumns([...contentIds], fwdEdges);
@@ -1476,7 +1513,7 @@ function layoutSubProcess(children, edges) {
   for (let c = 0; c <= maxCol; c++) colW.set(c, 0);
   for (const node of mainChildren) {
     const c = columns.get(node.id) ?? 0;
-    colW.set(c, Math.max(colW.get(c) ?? 0, layoutW(node)));
+    colW.set(c, Math.max(colW.get(c) ?? 0, columnW(node)));
   }
   const colX = /* @__PURE__ */ new Map();
   let cumX = 0;
@@ -1485,20 +1522,16 @@ function layoutSubProcess(children, edges) {
     cumX += (colW.get(c) ?? 120) + COL_GAP;
   }
   const contentW = cumX - COL_GAP;
-  const rowVals = [...rows.values()];
-  const minRow = Math.min(0, ...rowVals);
-  const maxRow = Math.max(0, ...rowVals);
-  const rowCount = maxRow - minRow + 1;
-  const contentH = rowCount * ROW_HEIGHT + Math.max(0, rowCount - 1) * ROW_GAP;
+  const rowMetrics = computeRowMetrics(mainChildren, rows, true);
   const spW = Math.max(280, SP_PAD * 2 + contentW);
-  const spH = Math.max(160, SP_PAD * 2 + contentH);
+  const spH = Math.max(160, SP_PAD * 2 + rowMetrics.contentH);
   const positionedChildren = mainChildren.map((node) => {
     const c = columns.get(node.id) ?? 0;
     const r = rows.get(node.id) ?? 0;
     const lw = layoutW(node);
     const lh = layoutH(node);
     const colOffset = (colX.get(c) ?? 0) + (colW.get(c) ?? 120) / 2 - lw / 2;
-    const rowOffset = (r - minRow) * (ROW_HEIGHT + ROW_GAP) + ROW_HEIGHT / 2 - lh / 2;
+    const rowOffset = (rowMetrics.rowY.get(r) ?? 0) + (rowMetrics.rowH.get(r) ?? ROW_HEIGHT) / 2 - lh / 2;
     return applyLayoutMinSize({ ...node, position: { x: SP_PAD + colOffset, y: SP_PAD + rowOffset } });
   });
   const positionedBoundaries = repositionBoundaryEvents(boundaryEvents, positionedChildren);
@@ -1541,7 +1574,8 @@ function layoutPool(pool, lanes, content, allEdges) {
     nodeLaneId.set(node.id, lId);
   }
   const contentIds = new Set(mainContent.map((n) => n.id));
-  const seqEdges = extractSeqEdges(allEdges, contentIds);
+  const graphEdges = reanchorBoundaryEdges(allEdges, boundaryEvents, contentIds);
+  const seqEdges = extractSeqEdges(graphEdges, contentIds);
   const backIds = detectBackEdges([...contentIds], seqEdges);
   const fwdEdges = seqEdges.filter((e) => !backIds.has(e.id));
   const columns = assignColumns([...contentIds], fwdEdges);
@@ -1552,47 +1586,107 @@ function layoutPool(pool, lanes, content, allEdges) {
     if (!contentByLane.has(lId)) contentByLane.set(lId, []);
     contentByLane.get(lId).push(node);
   }
+  const laneStackIndex = /* @__PURE__ */ new Map();
+  sortedLanes.forEach((laneNode, index) => laneStackIndex.set(laneNode.id, index));
+  laneStackIndex.set("_pool_", sortedLanes.length);
+  const crossLanePull = /* @__PURE__ */ new Map();
+  for (const e of fwdEdges) {
+    const sLane = nodeLaneId.get(e.source) ?? "_pool_";
+    const tLane = nodeLaneId.get(e.target) ?? "_pool_";
+    if (sLane === tLane) continue;
+    const dir = Math.sign((laneStackIndex.get(tLane) ?? 0) - (laneStackIndex.get(sLane) ?? 0));
+    crossLanePull.set(e.source, (crossLanePull.get(e.source) ?? 0) + dir);
+    crossLanePull.set(e.target, (crossLanePull.get(e.target) ?? 0) - dir);
+  }
   for (const [, laneNodes] of contentByLane) {
     const laneNodeIds = new Set(laneNodes.map((n) => n.id));
     const intraEdges = fwdEdges.filter(
       (e) => laneNodeIds.has(e.source) && laneNodeIds.has(e.target)
     );
     const lanePairs = detectGatewayPairs(laneNodes, intraEdges);
-    const laneRows = assignRows(laneNodes, intraEdges, columns, lanePairs);
+    const laneRows = assignRows(laneNodes, intraEdges, columns, lanePairs, crossLanePull);
     for (const [id, row] of laneRows) rows.set(id, row);
   }
-  const laneIds = hasLanes ? sortedLanes.map((l) => l.id) : ["_pool_"];
+  const seqTouched = /* @__PURE__ */ new Set();
+  for (const e of seqEdges) {
+    seqTouched.add(e.source);
+    seqTouched.add(e.target);
+  }
+  for (const [, laneNodes] of contentByLane) {
+    const eventSPs = laneNodes.filter(
+      (n) => n.data.elementType === "EventSubProcess" && !seqTouched.has(n.id)
+    );
+    if (eventSPs.length === 0) continue;
+    const eventSpIds = new Set(eventSPs.map((n) => n.id));
+    const otherRows = laneNodes.filter((n) => !eventSpIds.has(n.id)).map((n) => rows.get(n.id) ?? 0);
+    const laneMaxRow = otherRows.length > 0 ? Math.max(...otherRows) : -1;
+    for (const sp of eventSPs) rows.set(sp.id, laneMaxRow + 1);
+  }
+  const hasPoolDirectContent = [...nodeLaneId.values()].includes("_pool_");
+  const laneIds = hasLanes ? [...sortedLanes.map((l) => l.id), ...hasPoolDirectContent ? ["_pool_"] : []] : ["_pool_"];
   const laneStats = /* @__PURE__ */ new Map();
   for (const laneId of laneIds) {
-    const laneRows = mainContent.filter((n) => nodeLaneId.get(n.id) === laneId).map((n) => rows.get(n.id) ?? 0);
-    if (laneRows.length === 0) {
-      laneStats.set(laneId, { minRow: 0, maxRow: 0, rowCount: 1, height: LANE_MIN_H });
+    const laneNodes = mainContent.filter((n) => nodeLaneId.get(n.id) === laneId);
+    if (laneNodes.length === 0) {
+      laneStats.set(laneId, {
+        minRow: 0,
+        maxRow: 0,
+        height: LANE_MIN_H,
+        contentH: ROW_HEIGHT,
+        rowH: /* @__PURE__ */ new Map([[0, ROW_HEIGHT]]),
+        rowY: /* @__PURE__ */ new Map([[0, 0]])
+      });
     } else {
-      const minRow = Math.min(...laneRows);
-      const maxRow = Math.max(...laneRows);
-      const rowCount = maxRow - minRow + 1;
-      const contentH = rowCount * ROW_HEIGHT + Math.max(0, rowCount - 1) * ROW_GAP;
-      const height = Math.max(LANE_MIN_H, LANE_V_PAD * 2 + contentH);
-      laneStats.set(laneId, { minRow, maxRow, rowCount, height });
+      const m = computeRowMetrics(laneNodes, rows, false);
+      const height = Math.max(LANE_MIN_H, LANE_V_PAD * 2 + m.contentH);
+      laneStats.set(laneId, {
+        minRow: m.minRow,
+        maxRow: m.maxRow,
+        height,
+        contentH: m.contentH,
+        rowH: m.rowH,
+        rowY: m.rowY
+      });
     }
   }
-  const maxCol = Math.max(0, ...[...columns.values()]);
-  const colW = /* @__PURE__ */ new Map();
-  for (let c = 0; c <= maxCol; c++) colW.set(c, 0);
-  for (const node of mainContent) {
-    const c = columns.get(node.id) ?? 0;
-    colW.set(c, Math.max(colW.get(c) ?? 0, layoutW(node)));
-  }
-  const colX = /* @__PURE__ */ new Map();
-  let cumX = 0;
-  for (let c = 0; c <= maxCol; c++) {
-    colX.set(c, cumX);
-    cumX += (colW.get(c) ?? 120) + COL_GAP;
+  const laneColumnLayouts = /* @__PURE__ */ new Map();
+  for (const laneId of laneIds) {
+    const laneNodes = mainContent.filter(
+      (node) => (nodeLaneId.get(node.id) ?? "_pool_") === laneId
+    );
+    const usedCols = [...new Set(laneNodes.map((node) => columns.get(node.id) ?? 0))].sort((a, b) => a - b);
+    const colW = /* @__PURE__ */ new Map();
+    for (const col of usedCols) colW.set(col, 0);
+    for (const node of laneNodes) {
+      const col = columns.get(node.id) ?? 0;
+      colW.set(col, Math.max(colW.get(col) ?? 0, columnW(node)));
+    }
+    const colX = /* @__PURE__ */ new Map();
+    let laneCumX = 0;
+    for (const col of usedCols) {
+      colX.set(col, laneCumX);
+      laneCumX += (colW.get(col) ?? 120) + COL_GAP;
+    }
+    laneColumnLayouts.set(laneId, {
+      colW,
+      colX,
+      contentW: usedCols.length > 0 ? laneCumX - COL_GAP : 0
+    });
   }
-  const contentW = cumX - COL_GAP;
-  const innerW = LANE_LABEL_W + LANE_H_PAD + contentW + LANE_H_PAD;
+  const baseLaneInnerW = Math.max(
+    0,
+    ...laneIds.filter((laneId) => laneId !== "_pool_").map((laneId) => {
+      const contentW = laneColumnLayouts.get(laneId)?.contentW ?? 0;
+      return LANE_LABEL_W + LANE_H_PAD + contentW + LANE_H_PAD;
+    })
+  );
+  const basePoolInnerW = Math.max(
+    0,
+    ...laneIds.filter((laneId) => laneId === "_pool_").map((laneId) => (laneColumnLayouts.get(laneId)?.contentW ?? 0) + POOL_H_PAD * 2)
+  );
+  const innerW = Math.max(baseLaneInnerW, basePoolInnerW);
   const poolW = Math.max(POOL_MIN_W, innerW + POOL_INNER_PAD * 2);
-  const laneW = poolW - POOL_INNER_PAD * 2;
+  let laneW = poolW - POOL_INNER_PAD * 2;
   const laneY = /* @__PURE__ */ new Map();
   let cumY = POOL_INNER_PAD;
   for (let i = 0; i < laneIds.length; i++) {
@@ -1607,20 +1701,106 @@ function layoutPool(pool, lanes, content, allEdges) {
     const r = rows.get(node.id) ?? 0;
     const laneId = nodeLaneId.get(node.id) ?? "_pool_";
     const stat = laneStats.get(laneId);
+    const laneLayout = laneColumnLayouts.get(laneId);
     const lYOff = laneY.get(laneId) ?? 0;
     const lw = layoutW(node);
     const lh = layoutH(node);
-    const colOffset = (colX.get(c) ?? 0) + (colW.get(c) ?? 120) / 2 - lw / 2;
-    const rowOffset = (r - stat.minRow) * (ROW_HEIGHT + ROW_GAP) + ROW_HEIGHT / 2 - lh / 2;
-    const contentH_stat = stat.rowCount * ROW_HEIGHT + Math.max(0, stat.rowCount - 1) * ROW_GAP;
-    const vertTopOffset = Math.max(LANE_V_PAD, (stat.height - contentH_stat) / 2);
+    const colOffset = (laneLayout?.colX.get(c) ?? 0) + (laneLayout?.colW.get(c) ?? 120) / 2 - lw / 2;
+    const rowOffset = (stat.rowY.get(r) ?? 0) + (stat.rowH.get(r) ?? ROW_HEIGHT) / 2 - lh / 2;
+    const vertTopOffset = Math.max(LANE_V_PAD, (stat.height - stat.contentH) / 2);
     const isLaneChild = hasLanes && !!node.parentId && node.parentId !== pool.id;
     const x = isLaneChild ? LANE_LABEL_W + LANE_H_PAD + colOffset : POOL_H_PAD + colOffset;
     const y = isLaneChild ? vertTopOffset + rowOffset : lYOff + vertTopOffset + rowOffset;
     return applyLayoutMinSize({ ...node, position: { x, y } });
   });
+  const handoffAdjustedContent = [...positionedContent];
+  const nodeIndexById = new Map(handoffAdjustedContent.map((node, index) => [node.id, index]));
+  const outgoingBySource = /* @__PURE__ */ new Map();
+  for (const edge of fwdEdges) {
+    if (!outgoingBySource.has(edge.source)) outgoingBySource.set(edge.source, []);
+    outgoingBySource.get(edge.source).push(edge);
+  }
+  const crossLaneEdges = fwdEdges.filter((edge) => {
+    const srcLane = nodeLaneId.get(edge.source) ?? "_pool_";
+    const tgtLane = nodeLaneId.get(edge.target) ?? "_pool_";
+    return srcLane !== tgtLane;
+  }).sort(
+    (a, b) => (columns.get(a.target) ?? 0) - (columns.get(b.target) ?? 0) || (columns.get(a.source) ?? 0) - (columns.get(b.source) ?? 0)
+  );
+  for (const edge of crossLaneEdges) {
+    const srcIndex = nodeIndexById.get(edge.source);
+    const tgtIndex = nodeIndexById.get(edge.target);
+    if (srcIndex == null || tgtIndex == null) continue;
+    const srcNode = handoffAdjustedContent[srcIndex];
+    const tgtNode = handoffAdjustedContent[tgtIndex];
+    const tgtLaneId = nodeLaneId.get(tgtNode.id) ?? "_pool_";
+    const tgtCol = columns.get(tgtNode.id) ?? 0;
+    const siblingTargets = (outgoingBySource.get(edge.source) ?? []).filter((candidate) => (columns.get(candidate.target) ?? 0) === tgtCol).map((candidate) => handoffAdjustedContent[nodeIndexById.get(candidate.target) ?? -1]).filter((node) => !!node);
+    const siblingAlignedX = siblingTargets.reduce(
+      (max, node) => Math.max(max, node.position.x),
+      Number.NEGATIVE_INFINITY
+    );
+    const minTargetX = Math.max(
+      siblingAlignedX,
+      srcNode.position.x + layoutW(srcNode) / 2 + layoutW(tgtNode) / 2 + COL_GAP
+    );
+    if (tgtNode.position.x >= minTargetX) continue;
+    const delta = minTargetX - tgtNode.position.x;
+    for (let i = 0; i < handoffAdjustedContent.length; i++) {
+      const candidate = handoffAdjustedContent[i];
+      if ((nodeLaneId.get(candidate.id) ?? "_pool_") !== tgtLaneId) continue;
+      if ((columns.get(candidate.id) ?? 0) < tgtCol) continue;
+      handoffAdjustedContent[i] = {
+        ...candidate,
+        position: {
+          x: candidate.position.x + delta,
+          y: candidate.position.y
+        }
+      };
+    }
+  }
+  for (const [sourceId, outgoing] of outgoingBySource) {
+    if (outgoing.length < 2) continue;
+    const hasCrossLaneSibling = outgoing.some((edge) => {
+      const srcLane = nodeLaneId.get(edge.source) ?? "_pool_";
+      const tgtLane = nodeLaneId.get(edge.target) ?? "_pool_";
+      return srcLane !== tgtLane;
+    });
+    if (!hasCrossLaneSibling) continue;
+    const siblingsByCol = /* @__PURE__ */ new Map();
+    for (const edge of outgoing) {
+      const col = columns.get(edge.target) ?? 0;
+      const node = handoffAdjustedContent[nodeIndexById.get(edge.target) ?? -1];
+      if (!node) continue;
+      if (!siblingsByCol.has(col)) siblingsByCol.set(col, []);
+      siblingsByCol.get(col).push(node);
+    }
+    for (const [col, siblings] of siblingsByCol) {
+      if (siblings.length < 2) continue;
+      const alignedX = Math.max(...siblings.map((node) => node.position.x));
+      for (let i = 0; i < handoffAdjustedContent.length; i++) {
+        const candidate = handoffAdjustedContent[i];
+        if (!siblings.some((node) => node.id === candidate.id)) continue;
+        const laneId = nodeLaneId.get(candidate.id) ?? "_pool_";
+        for (let j = 0; j < handoffAdjustedContent.length; j++) {
+          const maybeShift = handoffAdjustedContent[j];
+          if ((nodeLaneId.get(maybeShift.id) ?? "_pool_") !== laneId) continue;
+          if ((columns.get(maybeShift.id) ?? 0) < col) continue;
+          const delta = alignedX - candidate.position.x;
+          if (delta <= 0) continue;
+          handoffAdjustedContent[j] = {
+            ...maybeShift,
+            position: {
+              x: maybeShift.position.x + delta,
+              y: maybeShift.position.y
+            }
+          };
+        }
+      }
+    }
+  }
   const NODE_MIN_GAP = 24;
-  const resolvedContent = [...positionedContent];
+  const resolvedContent = [...handoffAdjustedContent];
   for (const laneId of laneIds) {
     const laneNodeIndices = resolvedContent.map((n, i) => ({ n, i })).filter(({ n }) => (nodeLaneId.get(n.id) ?? "_pool_") === laneId).sort((a, b) => a.n.position.x - b.n.position.x);
     for (let k = 1; k < laneNodeIndices.length; k++) {
@@ -1642,6 +1822,15 @@ function layoutPool(pool, lanes, content, allEdges) {
     }
   }
   const positionedBoundaries = repositionBoundaryEvents(boundaryEvents, resolvedContent);
+  const laneChildRight = resolvedContent.filter((node) => hasLanes && !!node.parentId && node.parentId !== pool.id).reduce((max, node) => Math.max(max, node.position.x + nW(node) + LANE_H_PAD), 0);
+  const poolChildRight = resolvedContent.filter((node) => !hasLanes || !node.parentId || node.parentId === pool.id).reduce((max, node) => Math.max(max, node.position.x + nW(node) + POOL_H_PAD), 0);
+  const boundaryRight = positionedBoundaries.reduce(
+    (max, node) => Math.max(max, node.position.x + nW(node) + (hasLanes ? LANE_H_PAD : POOL_H_PAD)),
+    0
+  );
+  const finalInnerW = Math.max(innerW, laneChildRight, poolChildRight, boundaryRight);
+  const finalPoolW = Math.max(POOL_MIN_W, finalInnerW + POOL_INNER_PAD * 2);
+  laneW = finalPoolW - POOL_INNER_PAD * 2;
   const positionedLanes = hasLanes ? sortedLanes.map((lane) => ({
     ...lane,
     position: { x: POOL_INNER_PAD, y: laneY.get(lane.id) ?? POOL_INNER_PAD },
@@ -1650,10 +1839,21 @@ function layoutPool(pool, lanes, content, allEdges) {
   })) : [];
   return {
     nodes: [...resolvedContent, ...positionedBoundaries, ...positionedLanes],
-    width: poolW,
+    width: finalPoolW,
     height: poolH
   };
 }
+function layoutVirtualContext(contextNodes, allEdges, offsetY) {
+  if (contextNodes.length === 0) return [];
+  const virtualPool = {
+    id: "__bpmn_virtual_pool__"};
+  const result = layoutPool(virtualPool, [], contextNodes, allEdges);
+  if (offsetY === 0) return result.nodes;
+  return result.nodes.map((n) => ({
+    ...n,
+    position: { x: n.position.x, y: n.position.y + offsetY }
+  }));
+}
 function absolutePos(nodeId, byId, cache) {
   const cached = cache.get(nodeId);
   if (cached) return cached;
@@ -1734,9 +1934,75 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
   const cache = /* @__PURE__ */ new Map();
   const abs = (id) => absolutePos(id, byId, cache);
   const sortedLanes = [...laneIds].map((id) => byId.get(id)).filter((n) => !!n).sort((a, b) => abs(a.id).y - abs(b.id).y);
-  return edges.map((edge) => {
+  const contentInfos = layoutNodes.filter((n) => !poolIds.has(n.id) && !laneIds.has(n.id)).map((n) => {
+    const p = abs(n.id);
+    return { id: n.id, x: p.x, y: p.y, w: nW(n), h: nH(n), poolId: poolOf(n, poolIds, byId) ?? null };
+  });
+  const findClearX = (desiredX, y0, y1, minX, maxX, excludeA, excludeB, poolId) => {
+    if (minX > maxX) return desiredX;
+    const clampX = (x) => Math.min(maxX, Math.max(minX, x));
+    const blockers = contentInfos.filter(
+      (c) => c.poolId === poolId && c.id !== excludeA && c.id !== excludeB && c.y < y1 && c.y + c.h > y0
+    );
+    const isFree = (x) => blockers.every((c) => x < c.x - 4 || x > c.x + c.w + 4);
+    const clamped = clampX(desiredX);
+    if (isFree(clamped)) return clamped;
+    const candidates = [];
+    for (const c of blockers) candidates.push(c.x - 8, c.x + c.w + 8);
+    const free = candidates.map(clampX).filter(isFree).sort((a, b) => Math.abs(a - desiredX) - Math.abs(b - desiredX));
+    return free.length > 0 ? free[0] : clamped;
+  };
+  const backEdgeOrder = /* @__PURE__ */ new Map();
+  for (const edge of [...edges].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0)) {
+    if (backEdgeIds.has(edge.id)) backEdgeOrder.set(edge.id, backEdgeOrder.size);
+  }
+  const routeMessageFlow = (edge) => {
+    const src = byId.get(edge.source);
+    const tgt = byId.get(edge.target);
+    if (!src || !tgt) return null;
+    const srcPoolId = poolOf(src, poolIds, byId);
+    const tgtPoolId = poolOf(tgt, poolIds, byId);
+    if (!srcPoolId || !tgtPoolId || srcPoolId === tgtPoolId) return null;
+    const srcPoolNode = byId.get(srcPoolId);
+    const tgtPoolNode = byId.get(tgtPoolId);
+    if (!srcPoolNode || !tgtPoolNode) return null;
+    const sAbs = abs(src.id);
+    const tAbs = abs(tgt.id);
+    const sCX = sAbs.x + nW(src) / 2;
+    const tCX = tAbs.x + nW(tgt) / 2;
+    const srcPoolAbs = abs(srcPoolId);
+    const tgtPoolAbs = abs(tgtPoolId);
+    const srcPoolBottom = srcPoolAbs.y + nH(srcPoolNode);
+    const tgtPoolBottom = tgtPoolAbs.y + nH(tgtPoolNode);
+    if (tgtPoolAbs.y >= srcPoolBottom) {
+      const corridorY = (srcPoolBottom + tgtPoolAbs.y) / 2;
+      return [
+        { x: sCX, y: sAbs.y + nH(src) },
+        { x: sCX, y: corridorY },
+        { x: tCX, y: corridorY },
+        { x: tCX, y: tAbs.y }
+      ];
+    }
+    if (srcPoolAbs.y >= tgtPoolBottom) {
+      const corridorY = (tgtPoolBottom + srcPoolAbs.y) / 2;
+      return [
+        { x: sCX, y: sAbs.y },
+        { x: sCX, y: corridorY },
+        { x: tCX, y: corridorY },
+        { x: tCX, y: tAbs.y + nH(tgt) }
+      ];
+    }
+    return null;
+  };
+  const routed = edges.map((edge) => {
     const edgeType = edge.data?.edgeType ?? edge.type;
     if (edgeType !== "sequenceFlow") {
+      if (edgeType === "messageFlow") {
+        const pts = routeMessageFlow(edge);
+        if (pts) {
+          return { ...edge, data: { ...edge.data, routingPoints: pts } };
+        }
+      }
       const d = { ...edge.data };
       delete d.routingPoints;
       return { ...edge, data: d };
@@ -1761,7 +2027,16 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
     }
     let routingPoints;
     if (backEdgeIds.has(edge.id)) {
-      const topY = Math.min(sAbs.y, tAbs.y) - BACK_EDGE_CLEARANCE;
+      const spanMinX = Math.min(tAbs.x, sAbs.x) - EDGE_ROUTE_PAD;
+      const spanMaxX = Math.max(tAbs.x + tW, sAbs.x + sW) + EDGE_ROUTE_PAD;
+      let topMost = Math.min(sAbs.y, tAbs.y);
+      for (const cand of contentInfos) {
+        if (cand.poolId !== srcPool) continue;
+        if (cand.x + cand.w < spanMinX || cand.x > spanMaxX) continue;
+        topMost = Math.min(topMost, cand.y);
+      }
+      const stagger = (backEdgeOrder.get(edge.id) ?? 0) * 14;
+      const topY = topMost - BACK_EDGE_CLEARANCE - stagger;
       routingPoints = [
         { x: sAbs.x + sW, y: sCY },
         { x: sAbs.x + sW + EDGE_ROUTE_PAD, y: sCY },
@@ -1775,7 +2050,16 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
       const tgtLane = byId.get(laneOf(tgt, laneIds, byId) ?? "");
       if (srcLane && tgtLane && laneIds.has(srcLane.id) && laneIds.has(tgtLane.id)) {
         const goingDown = tAbs.y > sAbs.y;
-        const sharedX = gapMidX(sAbs, sW, tAbs, tW);
+        const sharedX = findClearX(
+          gapMidX(sAbs, sW, tAbs, tW),
+          Math.min(sCY, tCY),
+          Math.max(sCY, tCY),
+          sAbs.x + sW + 6,
+          tAbs.x - EDGE_ROUTE_PAD - 4,
+          src.id,
+          tgt.id,
+          srcPool
+        );
         const srcLaneIdx = sortedLanes.findIndex((l) => l.id === srcLane.id);
         const tgtLaneIdx = sortedLanes.findIndex((l) => l.id === tgtLane.id);
         const pts = [];
@@ -1810,7 +2094,16 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
         }
         routingPoints = pts;
       } else {
-        const sharedX = gapMidX(sAbs, sW, tAbs, tW);
+        const sharedX = findClearX(
+          gapMidX(sAbs, sW, tAbs, tW),
+          Math.min(sCY, tCY),
+          Math.max(sCY, tCY),
+          sAbs.x + sW + 6,
+          tAbs.x - 6,
+          src.id,
+          tgt.id,
+          srcPool
+        );
         routingPoints = [
           { x: sAbs.x + sW, y: sCY },
           { x: sharedX, y: sCY },
@@ -1840,7 +2133,16 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
         const midX = routeMidX(sAbs, sW, tAbs, tW);
         const exitX = sAbs.x + sW;
         const entryX = tAbs.x;
-        const corridorX = Math.max(midX, exitX + EDGE_ROUTE_PAD);
+        const corridorX = findClearX(
+          Math.max(midX, exitX + EDGE_ROUTE_PAD),
+          Math.min(sCY, tCY),
+          Math.max(sCY, tCY),
+          exitX + 6,
+          entryX - 6,
+          src.id,
+          tgt.id,
+          srcPool
+        );
         routingPoints = [
           { x: exitX, y: sCY },
           { x: corridorX, y: sCY },
@@ -1851,9 +2153,81 @@ function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
     }
     return { ...edge, data: { ...edge.data, routingPoints } };
   });
+  return spreadVerticalChannels(routed);
+}
+var CHANNEL_GAP = 10;
+var CHANNEL_CLUSTER_TOL = 8;
+function spreadVerticalChannels(edges) {
+  const runs = [];
+  edges.forEach((edge, edgeIdx) => {
+    const pts = edge.data?.routingPoints;
+    if (!pts || pts.length < 4) return;
+    let i = 1;
+    while (i < pts.length) {
+      let j = i;
+      while (j < pts.length && Math.abs(pts[j].x - pts[j - 1].x) <= 0.5) j++;
+      if (j > i) {
+        const fromIdx = i - 1;
+        const toIdx = j - 1;
+        if (fromIdx > 0 && toIdx < pts.length - 1) {
+          const ys = pts.slice(fromIdx, toIdx + 1).map((p) => p.y);
+          const y0 = Math.min(...ys);
+          const y1 = Math.max(...ys);
+          if (y1 - y0 >= 4) {
+            runs.push({ edgeIdx, fromIdx, toIdx, x: pts[fromIdx].x, y0, y1 });
+          }
+        }
+        i = j + 1;
+      } else {
+        i++;
+      }
+    }
+  });
+  if (runs.length < 2) return edges;
+  runs.sort((a, b) => a.x - b.x);
+  const clusters = [];
+  for (const run of runs) {
+    const last = clusters[clusters.length - 1];
+    if (last && run.x - last[0].x <= CHANNEL_CLUSTER_TOL) last.push(run);
+    else clusters.push([run]);
+  }
+  const offsets = /* @__PURE__ */ new Map();
+  for (const cluster of clusters) {
+    if (cluster.length < 2) continue;
+    const colliding = cluster.filter(
+      (run) => cluster.some((other) => other !== run && run.y0 < other.y1 && other.y0 < run.y1)
+    );
+    if (colliding.length < 2) continue;
+    const ordered = [...colliding].sort((a, b) => {
+      const idA = edges[a.edgeIdx].id;
+      const idB = edges[b.edgeIdx].id;
+      return idA < idB ? -1 : idA > idB ? 1 : a.fromIdx - b.fromIdx;
+    });
+    ordered.forEach((run, k) => {
+      const off = Math.round((k - (ordered.length - 1) / 2) * CHANNEL_GAP);
+      if (off !== 0) offsets.set(run, off);
+    });
+  }
+  if (offsets.size === 0) return edges;
+  const runsByEdge = /* @__PURE__ */ new Map();
+  for (const [run, off] of offsets) {
+    if (!runsByEdge.has(run.edgeIdx)) runsByEdge.set(run.edgeIdx, []);
+    runsByEdge.get(run.edgeIdx).push(run);
+  }
+  return edges.map((edge, edgeIdx) => {
+    const edgeRuns = runsByEdge.get(edgeIdx);
+    if (!edgeRuns) return edge;
+    const pts = (edge.data?.routingPoints).map((p) => ({ ...p }));
+    for (const run of edgeRuns) {
+      const off = offsets.get(run);
+      for (let p = run.fromIdx; p <= run.toIdx; p++) pts[p].x += off;
+    }
+    return { ...edge, data: { ...edge.data, routingPoints: pts } };
+  });
 }
 var ARTIFACT_ABOVE_GAP = 16;
 var ARTIFACT_H_SPACING = 12;
+var ARTIFACT_EDGE_PAD = 4;
 function positionArtifacts(artifacts, resultNodes, edges, originalNodes) {
   if (artifacts.length === 0) return [];
   const byId = new Map(resultNodes.map((n) => [n.id, n]));
@@ -1894,11 +2268,21 @@ function positionArtifacts(artifacts, resultNodes, edges, originalNodes) {
     let desiredAbsX = connAbsP.x + nW(connNode) / 2 - totalW / 2;
     for (const artifact of arts) {
       const parentAbsP = artifact.parentId ? absPos(artifact.parentId) : { x: 0, y: 0 };
+      let relY = desiredAbsY - parentAbsP.y;
+      const parentNode = artifact.parentId ? byId.get(artifact.parentId) : void 0;
+      if (parentNode) {
+        if (relY < ARTIFACT_EDGE_PAD) {
+          const belowAbsY = connAbsP.y + nH(connNode) + ARTIFACT_ABOVE_GAP;
+          relY = belowAbsY - parentAbsP.y;
+        }
+        relY = Math.min(relY, nH(parentNode) - nH(artifact) - ARTIFACT_EDGE_PAD);
+        relY = Math.max(relY, ARTIFACT_EDGE_PAD);
+      }
       positioned.push({
         ...artifact,
         position: {
           x: desiredAbsX - parentAbsP.x,
-          y: desiredAbsY - parentAbsP.y
+          y: relY
         }
       });
       desiredAbsX += nW(artifact) + ARTIFACT_H_SPACING;
@@ -1963,9 +2347,17 @@ async function bpmnCustomLayout(nodes, edges) {
   const mainNodes = nodes.filter((n) => !LAYOUT_ARTIFACT_TYPES.has(n.data.elementType));
   const pools = mainNodes.filter((n) => n.data.elementType === "Pool");
   const lanes = mainNodes.filter((n) => n.data.elementType === "Lane");
-  const expandedSubProcesses = mainNodes.filter(
-    (n) => COLLAPSED_SUBPROCESS_TYPES.has(n.data.elementType) && n.data.isExpanded
-  );
+  const nodeDepthById = /* @__PURE__ */ new Map();
+  const mainById = new Map(mainNodes.map((n) => [n.id, n]));
+  const depthOf = (node) => {
+    const cached = nodeDepthById.get(node.id);
+    if (cached != null) return cached;
+    const parent = node.parentId ? mainById.get(node.parentId) : void 0;
+    const depth = parent ? depthOf(parent) + 1 : 0;
+    nodeDepthById.set(node.id, depth);
+    return depth;
+  };
+  const expandedSubProcesses = mainNodes.filter((n) => COLLAPSED_SUBPROCESS_TYPES.has(n.data.elementType) && n.data.isExpanded).sort((a, b) => depthOf(b) - depthOf(a));
   const subProcessLayouts = /* @__PURE__ */ new Map();
   const workingMainNodes = [...mainNodes];
   for (const sp of expandedSubProcesses) {
@@ -1983,15 +2375,30 @@ async function bpmnCustomLayout(nodes, edges) {
     }
   }
   const content = workingMainNodes.filter((n) => {
+    if (n.data.elementType === "BoundaryEvent") return false;
     if (!LAYOUT_CONTAINER_TYPES.has(n.data.elementType)) return true;
     if (COLLAPSED_SUBPROCESS_TYPES.has(n.data.elementType)) return true;
     return false;
   });
   if (pools.length === 0) {
-    const { bpmnElkLayout: bpmnElkLayout2 } = await Promise.resolve().then(() => (init_elk(), elk_exports));
-    const elkResult = await bpmnElkLayout2(nodes.filter((n) => !LAYOUT_ARTIFACT_TYPES.has(n.data.elementType)), edges);
-    const posArtifacts = positionArtifacts(artifacts, elkResult.nodes, edges, nodes);
-    return { nodes: sortNodesParentFirst([...elkResult.nodes, ...posArtifacts]), edges: elkResult.edges };
+    const isSpChild = (n) => !!n.parentId && subProcessLayouts.has(n.parentId);
+    const freeContent = content.filter((n) => !isSpChild(n));
+    const freeBoundaries = workingMainNodes.filter(
+      (n) => n.data.elementType === "BoundaryEvent" && !isSpChild(n)
+    );
+    const resultNodes2 = layoutVirtualContext([...freeContent, ...freeBoundaries], edges, 0);
+    for (const [, spLayout] of subProcessLayouts) {
+      for (const child of spLayout.children) resultNodes2.push(child);
+    }
+    const contentIds = new Set(freeContent.map((n) => n.id));
+    const seqEdges = extractSeqEdges(edges, contentIds);
+    const backIds = detectBackEdges([...contentIds], seqEdges);
+    const routedEdges2 = routeEdges(edges, resultNodes2, backIds, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set());
+    const posArtifacts = positionArtifacts(artifacts, resultNodes2, edges, nodes);
+    return {
+      nodes: sortNodesParentFirst([...resultNodes2, ...posArtifacts]),
+      edges: routedEdges2
+    };
   }
   const poolIds = new Set(pools.map((p) => p.id));
   const allLaneIds = new Set(lanes.map((l) => l.id));
@@ -2034,30 +2441,14 @@ async function bpmnCustomLayout(nodes, edges) {
   const layoutted = new Set(resultNodes.map((n) => n.id));
   const freeNodes = workingMainNodes.filter((n) => !layoutted.has(n.id));
   if (freeNodes.length > 0) {
-    const freeNodeIds = new Set(freeNodes.map((n) => n.id));
-    const freeEdges = edges.filter(
-      (e) => freeNodeIds.has(e.source) && freeNodeIds.has(e.target)
+    const freeFlow = freeNodes.filter(
+      (n) => n.data.elementType === "BoundaryEvent" || !LAYOUT_CONTAINER_TYPES.has(n.data.elementType) || COLLAPSED_SUBPROCESS_TYPES.has(n.data.elementType)
     );
-    try {
-      const { bpmnElkLayout: bpmnElkLayout2 } = await Promise.resolve().then(() => (init_elk(), elk_exports));
-      const elkFree = await bpmnElkLayout2(freeNodes, freeEdges);
-      const offsetY = stackY;
-      for (const node of elkFree.nodes) {
-        resultNodes.push({
-          ...node,
-          position: { x: node.position.x, y: node.position.y + offsetY }
-        });
-      }
-      const freeEdgeIds = new Set(freeEdges.map((e) => e.id));
-      const elkEdgeMap = new Map(elkFree.edges.map((e) => [e.id, e]));
-      for (let i = 0; i < edges.length; i++) {
-        if (freeEdgeIds.has(edges[i].id) && elkEdgeMap.has(edges[i].id)) {
-          edges[i] = elkEdgeMap.get(edges[i].id);
-        }
-      }
-    } catch {
-      for (const node of freeNodes) resultNodes.push(node);
+    const freeRest = freeNodes.filter((n) => !freeFlow.includes(n));
+    for (const node of layoutVirtualContext(freeFlow, edges, stackY)) {
+      resultNodes.push(node);
     }
+    for (const node of freeRest) resultNodes.push(node);
   }
   const routedEdges = routeEdges(edges, resultNodes, allBackEdgeIds, allLaneIds, poolIds);
   const positionedArtifacts = positionArtifacts(artifacts, resultNodes, edges, nodes);