@aranzatech/diagrams-bpmn 0.2.13 → 0.2.15

package/dist/layout/index.cjs

@@ -1,626 +1,23 @@
 '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');
 
-// src/layout/index.ts
+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/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);
 }
@@ -635,30 +32,624 @@ 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);
 }
@@ -674,45 +665,34 @@ function acceptsBoundaryEvents(type) {
 function getHandlePolicy(type) {
   return BPMN_ELEMENT_CATALOG[type].handlePolicy;
 }
-
-// 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
+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"
+    ]);
   }
-};
+});
 function inferBpmnEdgeType(state, sourceId, targetId) {
   const source = diagramsCore.getNode(state, sourceId);
   const target = diagramsCore.getNode(state, targetId);
@@ -807,82 +787,109 @@ function validateEdgeCardinality(state, edgeType, source, target) {
   }
   return 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;
-      }
-      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.";
+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
       }
-      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.";
+    };
+    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 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.`
-  ]
+    ];
+    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
 });
-var BPMN_CONTAINER_TYPES = /* @__PURE__ */ new Set([
-  "Pool",
-  "Lane",
-  "SubProcess",
-  "Transaction",
-  "EventSubProcess",
-  "AdHocSubProcess"
-]);
-var CONTAINER_MIN_SIZE = {
-  Pool: { w: 560, h: 160 },
-  Lane: { w: 480, h: 100 },
-  SubProcess: { w: 200, h: 120 },
-  Transaction: { w: 200, h: 120 },
-  EventSubProcess: { w: 200, h: 120 },
-  AdHocSubProcess: { w: 200, h: 120 }
-};
-var CONTAINER_PADDING = {
-  Pool: "[top=30,left=55,bottom=30,right=40]",
-  Lane: "[top=25,left=60,bottom=25,right=40]",
-  SubProcess: "[top=25,left=35,bottom=25,right=35]",
-  Transaction: "[top=25,left=35,bottom=25,right=35]",
-  EventSubProcess: "[top=25,left=35,bottom=25,right=35]",
-  AdHocSubProcess: "[top=25,left=35,bottom=25,right=35]"
-};
 async function bpmnElkLayout(nodes, edges) {
   const poolsWithLanes = /* @__PURE__ */ new Set();
   for (const node of nodes) {
@@ -902,13 +909,26 @@ async function bpmnElkLayout(nodes, edges) {
       },
       isContainerNode: (node) => BPMN_CONTAINER_TYPES.has(node.data.elementType),
       getNodeLayoutOptions: (node) => {
-        const type = node.data.elementType;
+        const bNode = node;
+        const type = bNode.data.elementType;
         if (!BPMN_CONTAINER_TYPES.has(type)) return void 0;
         const min = CONTAINER_MIN_SIZE[type];
-        const dir = type === "Pool" && poolsWithLanes.has(node.id) ? "DOWN" : "RIGHT";
+        const isPoolWithLanes = type === "Pool" && poolsWithLanes.has(node.id);
+        const dir = isPoolWithLanes ? "DOWN" : "RIGHT";
         return {
           "elk.direction": dir,
           "elk.nodeSize.constraints": "MINIMUM_SIZE",
+          // Each container handles its own layout pass so cross-lane edges
+          // participate in the internal layout without the global direction
+          // forcing Lane containers to align sideways.
+          "elk.hierarchyHandling": "INCLUDE_CHILDREN",
+          // Lanes within a Pool share a border — zero gap between them.
+          // Other containers keep the tighter inner spacing.
+          ...isPoolWithLanes ? { "elk.spacing.nodeNode": "0", "elk.spacing.componentComponent": "0" } : {
+            "elk.layered.spacing.nodeNodeBetweenLayers": "100",
+            "elk.layered.spacing.edgeNodeBetweenLayers": "45",
+            "elk.spacing.nodeNode": "50"
+          },
           ...min ? { "elk.nodeSize.minimum": `[w=${min.w},h=${min.h}]` } : {},
           ...CONTAINER_PADDING[type] ? { "elk.padding": CONTAINER_PADDING[type] } : {}
         };
@@ -916,27 +936,84 @@ async function bpmnElkLayout(nodes, edges) {
       elk: {
         "elk.algorithm": "layered",
         "elk.direction": "RIGHT",
-        "elk.hierarchyHandling": "INCLUDE_CHILDREN",
+        // INHERIT: each container handles its own INCLUDE_CHILDREN pass so
+        // the global RIGHT direction does not force Lane containers sideways.
+        "elk.hierarchyHandling": "INHERIT",
         "elk.edgeRouting": "ORTHOGONAL",
-        "elk.layered.spacing.nodeNodeBetweenLayers": "100",
-        "elk.layered.spacing.edgeNodeBetweenLayers": "40",
-        "elk.spacing.nodeNode": "60",
-        "elk.spacing.componentComponent": "80"
+        // Global spacing — generous values for visual breathing room.
+        "elk.layered.spacing.nodeNodeBetweenLayers": "120",
+        "elk.layered.spacing.edgeNodeBetweenLayers": "50",
+        "elk.spacing.nodeNode": "70",
+        "elk.spacing.componentComponent": "100"
       }
     }
   );
   const nodeMap = new Map(result.nodes.map((n) => [n.id, n]));
   const edgeMap = new Map(result.edges.map((e) => [e.id, e]));
+  const COMPONENT_GAP = 100;
+  const rootNodeOrder = nodes.filter((n) => !n.parentId).map((n) => n.id);
+  const rootHeights = /* @__PURE__ */ new Map();
+  for (const id of rootNodeOrder) {
+    const laid = nodeMap.get(id);
+    const orig = nodes.find((n) => n.id === id);
+    rootHeights.set(id, laid?.height ?? orig?.height ?? 200);
+  }
+  let stackY = 0;
+  const rootY = /* @__PURE__ */ new Map();
+  for (const id of rootNodeOrder) {
+    rootY.set(id, stackY);
+    stackY += (rootHeights.get(id) ?? 200) + COMPONENT_GAP;
+  }
   const updatedNodes = nodes.map((node) => {
     const laid = nodeMap.get(node.id);
     if (!laid) return node;
-    return { ...node, position: laid.position, width: laid.width, height: laid.height };
+    const pos = node.parentId ? laid.position : { x: laid.position.x, y: rootY.get(node.id) ?? laid.position.y };
+    return { ...node, position: pos, width: laid.width, height: laid.height };
   });
+  const lanesByPool = /* @__PURE__ */ new Map();
+  for (const node of updatedNodes) {
+    if (node.data.elementType === "Lane" && node.parentId) {
+      const arr = lanesByPool.get(node.parentId) ?? [];
+      arr.push(node.id);
+      lanesByPool.set(node.parentId, arr);
+    }
+  }
+  const nodeIndex = new Map(updatedNodes.map((n, i) => [n.id, i]));
+  for (const laneIds of lanesByPool.values()) {
+    const widths = laneIds.map((id) => updatedNodes[nodeIndex.get(id)]?.width ?? 0);
+    const maxWidth = Math.max(...widths);
+    if (maxWidth <= 0) continue;
+    for (const id of laneIds) {
+      const idx = nodeIndex.get(id);
+      if (idx !== void 0) {
+        updatedNodes[idx] = { ...updatedNodes[idx], width: maxWidth };
+      }
+    }
+  }
+  const nodeRootContainer = /* @__PURE__ */ new Map();
+  for (const node of updatedNodes) {
+    nodeRootContainer.set(node.id, node.parentId ?? null);
+  }
+  const getRootContainer = (nodeId) => {
+    let current = nodeId;
+    const visited = /* @__PURE__ */ new Set();
+    while (current) {
+      if (visited.has(current)) break;
+      visited.add(current);
+      const parent = nodeRootContainer.get(current);
+      if (!parent) return current;
+      current = parent;
+    }
+    return null;
+  };
   const updatedEdges = edges.map((edge) => {
     const laid = edgeMap.get(edge.id);
     if (!laid) return edge;
     const nextData = { ...edge.data };
-    if (laid.points && laid.points.length > 0) {
+    const sourceRoot = getRootContainer(edge.source);
+    const targetRoot = getRootContainer(edge.target);
+    const isCrossPool = sourceRoot !== targetRoot;
+    if (!isCrossPool && laid.points && laid.points.length > 0) {
       nextData.routingPoints = laid.points;
     } else {
       delete nextData.routingPoints;
@@ -945,6 +1022,601 @@ 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([
+  "Pool",
+  "Lane",
+  "SubProcess",
+  "Transaction",
+  "EventSubProcess",
+  "AdHocSubProcess"
+]);
+var LAYOUT_GATEWAY_TYPES = /* @__PURE__ */ new Set([
+  "ExclusiveGateway",
+  "InclusiveGateway",
+  "ParallelGateway",
+  "EventBasedGateway",
+  "ComplexGateway"
+]);
+function detectBackEdges(nodeIds, seqEdges) {
+  const backEdgeIds = /* @__PURE__ */ new Set();
+  const state = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) state.set(id, 0);
+  const adj = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) adj.set(id, []);
+  for (const e of seqEdges) {
+    adj.get(e.source)?.push({ target: e.target, edgeId: e.id });
+  }
+  for (const startId of nodeIds) {
+    if (state.get(startId) !== 0) continue;
+    const stack = [{ id: startId, idx: 0 }];
+    state.set(startId, 1);
+    while (stack.length > 0) {
+      const top = stack[stack.length - 1];
+      const neighbors = adj.get(top.id) ?? [];
+      if (top.idx >= neighbors.length) {
+        state.set(top.id, 2);
+        stack.pop();
+        continue;
+      }
+      const { target, edgeId } = neighbors[top.idx++];
+      const tState = state.get(target);
+      if (tState === 1) {
+        backEdgeIds.add(edgeId);
+      } else if (tState === 0) {
+        state.set(target, 1);
+        stack.push({ id: target, idx: 0 });
+      }
+    }
+  }
+  return backEdgeIds;
+}
+function extractSeqEdges(edges, nodeIds) {
+  return edges.filter((e) => {
+    const t = e.data?.edgeType ?? e.type;
+    return t === "sequenceFlow" && nodeIds.has(e.source) && nodeIds.has(e.target);
+  }).map((e) => ({ id: e.id, source: e.source, target: e.target, sourceHandle: e.sourceHandle ?? null }));
+}
+function topologicalSort(nodeIds, forwardEdges) {
+  const inDeg = new Map(nodeIds.map((id) => [id, 0]));
+  const adj = new Map(nodeIds.map((id) => [id, []]));
+  for (const e of forwardEdges) {
+    if (!inDeg.has(e.source) || !inDeg.has(e.target)) continue;
+    adj.get(e.source).push(e.target);
+    inDeg.set(e.target, (inDeg.get(e.target) ?? 0) + 1);
+  }
+  const queue = nodeIds.filter((id) => (inDeg.get(id) ?? 0) === 0);
+  const result = [];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    result.push(id);
+    for (const next of adj.get(id) ?? []) {
+      const d = (inDeg.get(next) ?? 1) - 1;
+      inDeg.set(next, d);
+      if (d === 0) queue.push(next);
+    }
+  }
+  const seen = new Set(result);
+  for (const id of nodeIds) {
+    if (!seen.has(id)) result.push(id);
+  }
+  return result;
+}
+function assignColumns(nodeIds, forwardEdges) {
+  const order = topologicalSort(nodeIds, forwardEdges);
+  const col = new Map(nodeIds.map((id) => [id, 0]));
+  const preds = new Map(nodeIds.map((id) => [id, []]));
+  for (const e of forwardEdges) {
+    preds.get(e.target)?.push(e.source);
+  }
+  for (const id of order) {
+    const predCols = (preds.get(id) ?? []).map((p) => col.get(p) ?? 0);
+    col.set(id, predCols.length > 0 ? Math.max(...predCols) + 1 : 0);
+  }
+  return col;
+}
+function detectGatewayPairs(nodes, forwardEdges) {
+  const pairs = /* @__PURE__ */ new Map();
+  const nodeIds = nodes.map((n) => n.id);
+  const succs = new Map(nodes.map((n) => [n.id, []]));
+  for (const e of forwardEdges) {
+    succs.get(e.source)?.push(e.target);
+  }
+  const order = topologicalSort(nodeIds, forwardEdges);
+  const topoPos = new Map(order.map((id, i) => [id, i]));
+  const splits = nodes.filter(
+    (n) => LAYOUT_GATEWAY_TYPES.has(n.data.elementType) && (succs.get(n.id)?.length ?? 0) > 1
+  );
+  for (const split of splits) {
+    const branches = succs.get(split.id) ?? [];
+    if (branches.length < 2) continue;
+    const branchSets = branches.map((start) => {
+      const visited = /* @__PURE__ */ new Set();
+      const q = [start];
+      while (q.length) {
+        const curr = q.shift();
+        if (visited.has(curr)) continue;
+        visited.add(curr);
+        for (const next of succs.get(curr) ?? []) q.push(next);
+      }
+      return visited;
+    });
+    const common = [...branchSets[0]].filter(
+      (id) => branchSets.every((s) => s.has(id))
+    );
+    if (common.length === 0) continue;
+    const merge = common.reduce(
+      (a, b) => (topoPos.get(a) ?? Infinity) < (topoPos.get(b) ?? Infinity) ? a : b
+    );
+    pairs.set(split.id, merge);
+  }
+  return pairs;
+}
+function handleToRowBias(handle) {
+  if (!handle) return null;
+  if (handle.includes("top")) return -1;
+  if (handle.includes("bottom")) return 1;
+  if (handle.includes("right")) return 0;
+  return null;
+}
+function buildHandleMap(edges) {
+  const map = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (!map.has(e.source)) map.set(e.source, /* @__PURE__ */ new Map());
+    map.get(e.source).set(e.target, e.sourceHandle ?? null);
+  }
+  return map;
+}
+function assignRows(nodes, forwardEdges, columns, gatewayPairs) {
+  const rows = new Map(nodes.map((n) => [n.id, 0]));
+  const succs = new Map(nodes.map((n) => [n.id, []]));
+  for (const e of forwardEdges) {
+    succs.get(e.source)?.push(e.target);
+  }
+  const handleMap = buildHandleMap(forwardEdges);
+  const sortedPairs = [...gatewayPairs.entries()].sort(
+    (a, b) => (columns.get(b[0]) ?? 0) - (columns.get(a[0]) ?? 0)
+  );
+  for (const [splitId, mergeId] of sortedPairs) {
+    const branches = succs.get(splitId) ?? [];
+    if (branches.length < 2) continue;
+    const splitRow = rows.get(splitId) ?? 0;
+    const getBranchNodes = (branchStart) => {
+      const result = [];
+      const visited = /* @__PURE__ */ new Set();
+      const q = [branchStart];
+      while (q.length) {
+        const curr = q.shift();
+        if (visited.has(curr) || curr === mergeId) continue;
+        visited.add(curr);
+        result.push(curr);
+        for (const next of succs.get(curr) ?? []) q.push(next);
+      }
+      return result;
+    };
+    const splitHandles = handleMap.get(splitId);
+    const branchData = branches.map((start) => ({
+      start,
+      nodeIds: getBranchNodes(start),
+      bias: handleToRowBias(splitHandles?.get(start) ?? null)
+    }));
+    const withBias = branchData.filter((b) => b.bias !== null && b.bias !== 0);
+    const withoutBias = branchData.filter((b) => b.bias === null || b.bias === 0).sort((a, b) => b.nodeIds.length - a.nodeIds.length);
+    const assigned = /* @__PURE__ */ new Map();
+    for (const b of withBias) {
+      assigned.set(b.start, splitRow + b.bias);
+    }
+    let nextOffset = 0;
+    for (const b of withoutBias) {
+      while ([...assigned.values()].includes(splitRow + nextOffset)) nextOffset++;
+      assigned.set(b.start, splitRow + nextOffset);
+      nextOffset++;
+    }
+    for (const b of branchData) {
+      const row = assigned.get(b.start) ?? splitRow;
+      for (const id of b.nodeIds) {
+        rows.set(id, row);
+      }
+    }
+  }
+  const pairedSplits = new Set(gatewayPairs.keys());
+  const unpairedSplits = nodes.filter(
+    (n) => LAYOUT_GATEWAY_TYPES.has(n.data.elementType) && !pairedSplits.has(n.id) && (succs.get(n.id)?.length ?? 0) > 1
+  );
+  for (const split of unpairedSplits) {
+    const branches = succs.get(split.id) ?? [];
+    if (branches.length < 2) continue;
+    const splitRow = rows.get(split.id) ?? 0;
+    const getAllReachable = (start) => {
+      const result = [];
+      const visited = /* @__PURE__ */ new Set();
+      const q = [start];
+      while (q.length) {
+        const curr = q.shift();
+        if (visited.has(curr)) continue;
+        visited.add(curr);
+        result.push(curr);
+        for (const next of succs.get(curr) ?? []) q.push(next);
+      }
+      return result;
+    };
+    const splitHandles2 = handleMap.get(split.id);
+    const branchData = branches.map((start) => ({
+      start,
+      nodeIds: getAllReachable(start),
+      bias: handleToRowBias(splitHandles2?.get(start) ?? null)
+    }));
+    const withBias2 = branchData.filter((b) => b.bias !== null && b.bias !== 0);
+    const withoutBias2 = branchData.filter((b) => b.bias === null || b.bias === 0).sort((a, b) => b.nodeIds.length - a.nodeIds.length);
+    const assigned2 = /* @__PURE__ */ new Map();
+    for (const b of withBias2) assigned2.set(b.start, splitRow + b.bias);
+    let nextOff = 0;
+    for (const b of withoutBias2) {
+      while ([...assigned2.values()].includes(splitRow + nextOff)) nextOff++;
+      assigned2.set(b.start, splitRow + nextOff);
+      nextOff++;
+    }
+    for (const b of branchData) {
+      const row = assigned2.get(b.start) ?? splitRow;
+      for (const id of b.nodeIds) rows.set(id, row);
+    }
+  }
+  return rows;
+}
+
+// src/layout/bpmn-custom-layout.ts
+var LANE_LABEL_W = 28;
+var LANE_H_PAD = 20;
+var COL_GAP = 80;
+var ROW_HEIGHT = 80;
+var ROW_GAP = 60;
+var LANE_V_PAD = 50;
+var POOL_H_PAD = 60;
+var POOL_V_GAP = 50;
+var LANE_MIN_H = 160;
+var POOL_MIN_W = 720;
+var POOL_INNER_PAD = 8;
+function nW(node) {
+  return node.width ?? node.measured?.width ?? 120;
+}
+function nH(node) {
+  return node.height ?? node.measured?.height ?? 60;
+}
+function layoutPool(pool, lanes, content, allEdges) {
+  if (content.length === 0) {
+    if (lanes.length === 0) {
+      return { nodes: [], width: 240, height: 120 };
+    }
+    const laneH = LANE_MIN_H;
+    const h = POOL_INNER_PAD * 2 + lanes.length * laneH + Math.max(0, lanes.length - 1) * POOL_INNER_PAD;
+    const w = POOL_MIN_W;
+    return {
+      nodes: lanes.map((lane, i) => ({
+        ...lane,
+        position: { x: POOL_INNER_PAD, y: POOL_INNER_PAD + i * (laneH + POOL_INNER_PAD) },
+        width: w - POOL_INNER_PAD * 2,
+        height: laneH
+      })),
+      width: w,
+      height: h
+    };
+  }
+  const contentIds = new Set(content.map((n) => n.id));
+  const seqEdges = extractSeqEdges(allEdges, contentIds);
+  const backIds = detectBackEdges([...contentIds], seqEdges);
+  const fwdEdges = seqEdges.filter((e) => !backIds.has(e.id));
+  const columns = assignColumns([...contentIds], fwdEdges);
+  const pairs = detectGatewayPairs(content, fwdEdges);
+  const rows = assignRows(content, fwdEdges, columns, pairs);
+  const lanePositionsDistinct = lanes.some((l) => Math.abs(l.position.y) > 10);
+  const sortedLanes = lanePositionsDistinct ? [...lanes].sort((a, b) => a.position.y - b.position.y) : [...lanes];
+  const hasLanes = sortedLanes.length > 0;
+  const nodeLaneId = /* @__PURE__ */ new Map();
+  for (const node of content) {
+    if (hasLanes && node.parentId && node.parentId !== pool.id) {
+      nodeLaneId.set(node.id, node.parentId);
+    } else {
+      nodeLaneId.set(node.id, "_pool_");
+    }
+  }
+  const laneIds = hasLanes ? sortedLanes.map((l) => l.id) : ["_pool_"];
+  const laneStats = /* @__PURE__ */ new Map();
+  for (const laneId of laneIds) {
+    const laneRows = content.filter((n) => nodeLaneId.get(n.id) === laneId).map((n) => rows.get(n.id) ?? 0);
+    if (laneRows.length === 0) {
+      laneStats.set(laneId, { minRow: 0, maxRow: 0, rowCount: 1, height: LANE_MIN_H });
+    } else {
+      const minRow = Math.min(...laneRows);
+      const maxRow = Math.max(...laneRows);
+      const rowCount = maxRow - minRow + 1;
+      const contentH = rowCount * ROW_HEIGHT + Math.max(0, rowCount - 1) * ROW_GAP;
+      const height = Math.max(LANE_MIN_H, LANE_V_PAD * 2 + contentH);
+      laneStats.set(laneId, { minRow, maxRow, rowCount, height });
+    }
+  }
+  const maxCol = Math.max(0, ...[...columns.values()]);
+  const colW = /* @__PURE__ */ new Map();
+  for (let c = 0; c <= maxCol; c++) colW.set(c, 0);
+  for (const node of content) {
+    const c = columns.get(node.id) ?? 0;
+    colW.set(c, Math.max(colW.get(c) ?? 0, nW(node)));
+  }
+  const colX = /* @__PURE__ */ new Map();
+  let cumX = 0;
+  for (let c = 0; c <= maxCol; c++) {
+    colX.set(c, cumX);
+    cumX += (colW.get(c) ?? 120) + COL_GAP;
+  }
+  const contentW = cumX - COL_GAP;
+  const innerW = LANE_LABEL_W + LANE_H_PAD + contentW + LANE_H_PAD;
+  const poolW = Math.max(POOL_MIN_W, innerW + POOL_INNER_PAD * 2);
+  const laneW = poolW - POOL_INNER_PAD * 2;
+  const laneY = /* @__PURE__ */ new Map();
+  let cumY = POOL_INNER_PAD;
+  for (let i = 0; i < laneIds.length; i++) {
+    const laneId = laneIds[i];
+    laneY.set(laneId, cumY);
+    cumY += laneStats.get(laneId)?.height ?? LANE_MIN_H;
+    if (i < laneIds.length - 1) cumY += POOL_INNER_PAD;
+  }
+  const poolH = cumY + POOL_INNER_PAD;
+  const positionedContent = content.map((node) => {
+    const c = columns.get(node.id) ?? 0;
+    const r = rows.get(node.id) ?? 0;
+    const laneId = nodeLaneId.get(node.id) ?? "_pool_";
+    const stat = laneStats.get(laneId);
+    const lYOff = laneY.get(laneId) ?? 0;
+    const colOffset = (colX.get(c) ?? 0) + (colW.get(c) ?? 120) / 2 - nW(node) / 2;
+    const rowOffset = (r - stat.minRow) * (ROW_HEIGHT + ROW_GAP) + ROW_HEIGHT / 2 - nH(node) / 2;
+    const isLaneChild = hasLanes && !!node.parentId && node.parentId !== pool.id;
+    const contentH_stat = stat.rowCount * ROW_HEIGHT + Math.max(0, stat.rowCount - 1) * ROW_GAP;
+    const vertTopOffset = Math.max(LANE_V_PAD, (stat.height - contentH_stat) / 2);
+    const x = isLaneChild ? LANE_LABEL_W + LANE_H_PAD + colOffset : POOL_H_PAD + colOffset;
+    const y = isLaneChild ? vertTopOffset + rowOffset : lYOff + vertTopOffset + rowOffset;
+    return { ...node, position: { x, y } };
+  });
+  const NODE_MIN_GAP = 20;
+  const resolvedContent = [...positionedContent];
+  for (const laneId of laneIds) {
+    const laneNodeIndices = resolvedContent.map((n, i) => ({ n, i })).filter(({ n }) => (nodeLaneId.get(n.id) ?? "_pool_") === laneId).sort((a, b) => a.n.position.x - b.n.position.x);
+    for (let k = 1; k < laneNodeIndices.length; k++) {
+      const prev = resolvedContent[laneNodeIndices[k - 1].i];
+      const curr = resolvedContent[laneNodeIndices[k].i];
+      const prevBottom = prev.position.y + nH(prev);
+      const currTop = curr.position.y;
+      const prevTop = prev.position.y;
+      const currBottom = curr.position.y + nH(curr);
+      const yOverlap = prevBottom + NODE_MIN_GAP > currTop && currBottom + NODE_MIN_GAP > prevTop;
+      if (!yOverlap) continue;
+      const prevRight = prev.position.x + nW(prev);
+      if (prevRight + NODE_MIN_GAP > curr.position.x) {
+        resolvedContent[laneNodeIndices[k].i] = {
+          ...curr,
+          position: {
+            x: prevRight + NODE_MIN_GAP,
+            y: curr.position.y
+          }
+        };
+      }
+    }
+  }
+  const positionedLanes = hasLanes ? sortedLanes.map((lane) => ({
+    ...lane,
+    // x: after pool label strip + left inner padding
+    // y: laneY already includes top POOL_INNER_PAD offset
+    position: { x: POOL_INNER_PAD, y: laneY.get(lane.id) ?? POOL_INNER_PAD },
+    width: laneW,
+    height: laneStats.get(lane.id)?.height ?? LANE_MIN_H
+  })) : [];
+  return {
+    nodes: [...resolvedContent, ...positionedLanes],
+    width: poolW,
+    height: poolH
+  };
+}
+var BACK_EDGE_CLEARANCE = 50;
+var SAME_ROW_THRESHOLD = 15;
+function absolutePos(nodeId, byId, cache) {
+  const cached = cache.get(nodeId);
+  if (cached) return cached;
+  const node = byId.get(nodeId);
+  if (!node) return { x: 0, y: 0 };
+  const own = { ...node.position };
+  if (!node.parentId) {
+    cache.set(nodeId, own);
+    return own;
+  }
+  const parent = absolutePos(node.parentId, byId, cache);
+  const abs = { x: parent.x + own.x, y: parent.y + own.y };
+  cache.set(nodeId, abs);
+  return abs;
+}
+function laneOf(node, laneIds) {
+  return node.parentId && laneIds.has(node.parentId) ? node.parentId : void 0;
+}
+function routeEdges(edges, layoutNodes, backEdgeIds, laneIds, poolIds) {
+  const byId = new Map(layoutNodes.map((n) => [n.id, n]));
+  const cache = /* @__PURE__ */ new Map();
+  const abs = (id) => absolutePos(id, byId, cache);
+  return edges.map((edge) => {
+    const edgeType = edge.data?.edgeType ?? edge.type;
+    if (edgeType !== "sequenceFlow") {
+      const d = { ...edge.data };
+      delete d.routingPoints;
+      return { ...edge, data: d };
+    }
+    const src = byId.get(edge.source);
+    const tgt = byId.get(edge.target);
+    if (!src || !tgt) return edge;
+    const sAbs = abs(src.id);
+    const tAbs = abs(tgt.id);
+    const sW = nW(src), sH = nH(src);
+    const tW = nW(tgt), tH = nH(tgt);
+    const sCX = sAbs.x + sW / 2, sCY = sAbs.y + sH / 2;
+    const tCX = tAbs.x + tW / 2, tCY = tAbs.y + tH / 2;
+    const srcPool = poolIds.has(src.parentId ?? "") ? src.parentId : poolIds.has(byId.get(src.parentId ?? "")?.parentId ?? "") ? byId.get(src.parentId ?? "")?.parentId : src.parentId;
+    const tgtPool = poolIds.has(tgt.parentId ?? "") ? tgt.parentId : poolIds.has(byId.get(tgt.parentId ?? "")?.parentId ?? "") ? byId.get(tgt.parentId ?? "")?.parentId : tgt.parentId;
+    if (srcPool !== tgtPool) {
+      const d = { ...edge.data };
+      delete d.routingPoints;
+      return { ...edge, data: d };
+    }
+    let routingPoints;
+    if (backEdgeIds.has(edge.id)) {
+      const topY = Math.min(sAbs.y, tAbs.y) - BACK_EDGE_CLEARANCE;
+      routingPoints = [
+        { x: sCX, y: sAbs.y },
+        // [0] discarded
+        { x: sCX, y: topY },
+        // [1] go up
+        { x: tCX, y: topY },
+        // [2] go left/right
+        { x: tCX, y: tAbs.y }
+        // [3] discarded
+      ];
+    } else if (laneOf(src, laneIds) !== laneOf(tgt, laneIds)) {
+      const goingDown = tAbs.y > sAbs.y;
+      const sharedX = Math.abs(sCX - tCX) < 10 ? sCX : (sCX + tCX) / 2;
+      const srcLane = byId.get(src.parentId ?? "");
+      const tgtLane = byId.get(tgt.parentId ?? "");
+      if (srcLane && tgtLane && laneIds.has(srcLane.id) && laneIds.has(tgtLane.id)) {
+        const srcLaneAbs = abs(srcLane.id);
+        const borderY = goingDown ? srcLaneAbs.y + (srcLane.height ?? 160) : srcLaneAbs.y;
+        routingPoints = [
+          { x: sCX, y: goingDown ? sAbs.y + sH : sAbs.y },
+          // [0] discarded
+          { x: sharedX, y: goingDown ? sAbs.y + sH : sAbs.y },
+          // [1] bend: horizontal exit
+          { x: sharedX, y: borderY },
+          // [2] bend: lane border
+          { x: sharedX, y: goingDown ? tAbs.y : tAbs.y + tH }
+          // [3] discarded
+        ];
+      } else {
+        routingPoints = [
+          { x: sCX, y: sCY },
+          { x: sharedX, y: sCY },
+          { x: sharedX, y: tCY },
+          { x: tCX, y: tCY }
+        ];
+      }
+    } else if (Math.abs(sCY - tCY) <= SAME_ROW_THRESHOLD) {
+      const d = { ...edge.data };
+      delete d.routingPoints;
+      return { ...edge, data: d };
+    } else {
+      const handle = edge.sourceHandle ?? "";
+      const exitsTop = handle.includes("top");
+      const exitsBottom = handle.includes("bottom");
+      if (exitsTop || exitsBottom) {
+        routingPoints = [
+          { x: sCX, y: exitsTop ? sAbs.y : sAbs.y + sH },
+          // [0] discarded
+          { x: sCX, y: tCY },
+          // [1] vertical to target row
+          { x: tCX, y: tCY },
+          // [2] horizontal to target
+          { x: tCX, y: exitsTop ? tAbs.y + tH : tAbs.y }
+          // [3] discarded
+        ];
+      } else {
+        const goingRight = tAbs.x >= sAbs.x;
+        const midX = goingRight ? sAbs.x + sW + COL_GAP / 2 : sAbs.x - COL_GAP / 2;
+        routingPoints = [
+          { x: sAbs.x + sW, y: sCY },
+          // [0] discarded
+          { x: midX, y: sCY },
+          // [1] horizontal exit
+          { x: midX, y: tCY },
+          // [2] vertical to target row
+          { x: tAbs.x, y: tCY }
+          // [3] discarded
+        ];
+      }
+    }
+    return { ...edge, data: { ...edge.data, routingPoints } };
+  });
+}
+async function bpmnCustomLayout(nodes, edges) {
+  const pools = nodes.filter((n) => n.data.elementType === "Pool");
+  const lanes = nodes.filter((n) => n.data.elementType === "Lane");
+  const content = nodes.filter((n) => !LAYOUT_CONTAINER_TYPES.has(n.data.elementType));
+  if (pools.length === 0) {
+    const { bpmnElkLayout: bpmnElkLayout2 } = await Promise.resolve().then(() => (init_elk(), elk_exports));
+    return bpmnElkLayout2(nodes, edges);
+  }
+  const poolIds = new Set(pools.map((p) => p.id));
+  const allLaneIds = new Set(lanes.map((l) => l.id));
+  const allContentIds = new Set(content.map((n) => n.id));
+  const allSeqEdges = edges.filter((e) => {
+    const t = e.data?.edgeType ?? e.type;
+    return t === "sequenceFlow" && allContentIds.has(e.source) && allContentIds.has(e.target);
+  }).map((e) => ({ id: e.id, source: e.source, target: e.target }));
+  const allBackEdgeIds = detectBackEdges([...allContentIds], allSeqEdges);
+  const poolPositionsDistinct = pools.some((p) => Math.abs(p.position.y) > 10);
+  const sortedPools = poolPositionsDistinct ? [...pools].sort((a, b) => a.position.y - b.position.y) : [...pools];
+  const resultNodes = [];
+  let stackY = 0;
+  for (const pool of sortedPools) {
+    const poolLanes = lanes.filter((l) => l.parentId === pool.id);
+    const laneIds = new Set(poolLanes.map((l) => l.id));
+    const poolContent = content.filter(
+      (n) => n.parentId === pool.id || n.parentId != null && laneIds.has(n.parentId)
+    );
+    const result = layoutPool(pool, poolLanes, poolContent, edges);
+    resultNodes.push({
+      ...pool,
+      position: { x: 0, y: stackY },
+      width: result.width,
+      height: result.height
+    });
+    for (const node of result.nodes) {
+      resultNodes.push(node);
+    }
+    stackY += result.height + POOL_V_GAP;
+  }
+  const layoutted = new Set(resultNodes.map((n) => n.id));
+  for (const node of nodes) {
+    if (!layoutted.has(node.id)) resultNodes.push(node);
+  }
+  const routedEdges = routeEdges(edges, resultNodes, allBackEdgeIds, allLaneIds, poolIds);
+  return { nodes: resultNodes, edges: routedEdges };
+}
 
 // src/layout/index.ts
 async function bpmnDagreLayout(nodes, edges, options = {}) {
@@ -962,6 +1634,7 @@ Object.defineProperty(exports, "applyLayoutResultToDiagram", {
   get: function () { return layout.applyLayoutResultToDiagram; }
 });
 exports.applyBpmnLayoutResult = applyBpmnLayoutResult;
+exports.bpmnCustomLayout = bpmnCustomLayout;
 exports.bpmnDagreLayout = bpmnDagreLayout;
 exports.bpmnElkLayout = bpmnElkLayout;
 //# sourceMappingURL=index.cjs.map