@aranzatech/diagrams-bpmn 0.1.0

package/dist/index.cjs

@@ -0,0 +1,3442 @@
+'use strict';
+
+var react = require('@xyflow/react');
+var jsxRuntime = require('react/jsx-runtime');
+var routing = require('@aranzatech/diagrams-core/routing');
+var bpmnModdle = require('bpmn-moddle');
+
+// src/elements/catalog.ts
+var BPMN_ELEMENT_CATALOG = {
+  // ─── Events ──────────────────────────────────────────────────────────────────
+  StartEvent: {
+    label: "Start Event",
+    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",
+    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",
+    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",
+    category: "event",
+    defaultWidth: 36,
+    defaultHeight: 36,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    eventSemantics: "intermediateThrow",
+    canBeStart: false,
+    canBeEnd: false
+  },
+  BoundaryEvent: {
+    label: "Boundary Event",
+    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",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  UserTask: {
+    label: "User Task",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  ServiceTask: {
+    label: "Service Task",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  ScriptTask: {
+    label: "Script Task",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  ManualTask: {
+    label: "Manual Task",
+    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",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  ReceiveTask: {
+    label: "Receive Task",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  SendTask: {
+    label: "Send Task",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  CallActivity: {
+    label: "Call Activity",
+    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",
+    category: "gateway",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  InclusiveGateway: {
+    label: "Inclusive Gateway",
+    category: "gateway",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  ParallelGateway: {
+    label: "Parallel Gateway",
+    category: "gateway",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  EventBasedGateway: {
+    label: "Event-Based Gateway",
+    category: "gateway",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 1
+  },
+  ComplexGateway: {
+    label: "Complex Gateway",
+    category: "gateway",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  // ─── Containers ───────────────────────────────────────────────────────────────
+  SubProcess: {
+    label: "Sub-Process",
+    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",
+    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",
+    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",
+    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",
+    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",
+    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",
+    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",
+    category: "data",
+    defaultWidth: 36,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0
+  },
+  DataOutput: {
+    label: "Data Output",
+    category: "data",
+    defaultWidth: 36,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxOutgoing: 0
+  },
+  DataStore: {
+    label: "Data Store",
+    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",
+    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",
+    category: "conversation",
+    defaultWidth: 60,
+    defaultHeight: 52,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  SubConversation: {
+    label: "Sub-Conversation",
+    category: "conversation",
+    defaultWidth: 60,
+    defaultHeight: 52,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: true,
+    acceptsBoundaryEvents: false,
+    supportsCollapse: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  CallConversation: {
+    label: "Call Conversation",
+    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",
+    category: "choreography",
+    defaultWidth: 120,
+    defaultHeight: 80,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  SubChoreography: {
+    label: "Sub-Choreography",
+    category: "choreography",
+    defaultWidth: 120,
+    defaultHeight: 80,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: true,
+    acceptsBoundaryEvents: false,
+    supportsCollapse: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  CallChoreography: {
+    label: "Call Choreography",
+    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];
+}
+
+// src/elements/guards.ts
+var TASK_TYPES = /* @__PURE__ */ new Set([
+  "Task",
+  "UserTask",
+  "ServiceTask",
+  "ScriptTask",
+  "ManualTask",
+  "BusinessRuleTask",
+  "ReceiveTask",
+  "SendTask",
+  "CallActivity"
+]);
+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"
+]);
+var CONVERSATION_TYPES = /* @__PURE__ */ new Set([
+  "Conversation",
+  "SubConversation",
+  "CallConversation"
+]);
+var CHOREOGRAPHY_TYPES = /* @__PURE__ */ new Set([
+  "ChoreographyTask",
+  "SubChoreography",
+  "CallChoreography"
+]);
+function isTaskType(type) {
+  return TASK_TYPES.has(type);
+}
+function isGatewayType(type) {
+  return GATEWAY_TYPES.has(type);
+}
+function isEventType(type) {
+  return EVENT_TYPES.has(type);
+}
+function isDataType(type) {
+  return DATA_TYPES.has(type);
+}
+function isConversationType(type) {
+  return CONVERSATION_TYPES.has(type);
+}
+function isChoreographyType(type) {
+  return CHOREOGRAPHY_TYPES.has(type);
+}
+function isContainerType(type) {
+  return BPMN_ELEMENT_CATALOG[type].isContainer;
+}
+function acceptsBoundaryEvents(type) {
+  return BPMN_ELEMENT_CATALOG[type].acceptsBoundaryEvents;
+}
+function getHandlePolicy(type) {
+  return BPMN_ELEMENT_CATALOG[type].handlePolicy;
+}
+function getOrientation(type) {
+  return BPMN_ELEMENT_CATALOG[type].orientation;
+}
+function supportsCollapse(type) {
+  return BPMN_ELEMENT_CATALOG[type].supportsCollapse ?? false;
+}
+function supportsMarkers(type) {
+  return BPMN_ELEMENT_CATALOG[type].supportsMarkers ?? false;
+}
+var ALL_POSITIONS = [
+  react.Position.Top,
+  react.Position.Right,
+  react.Position.Bottom,
+  react.Position.Left
+];
+var HANDLE_STYLE = {
+  width: 8,
+  height: 8,
+  background: "#8c8c8c",
+  border: "1.5px solid #fff"
+};
+function BpmnHandles({ variant = "all" }) {
+  const src = variant === "all" || variant === "source";
+  const tgt = variant === "all" || variant === "target";
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    tgt && ALL_POSITIONS.map((position) => /* @__PURE__ */ jsxRuntime.jsx(
+      react.Handle,
+      {
+        type: "target",
+        position,
+        id: `target-${position}`,
+        style: HANDLE_STYLE
+      },
+      `target-${position}`
+    )),
+    src && ALL_POSITIONS.map((position) => /* @__PURE__ */ jsxRuntime.jsx(
+      react.Handle,
+      {
+        type: "source",
+        position,
+        id: `source-${position}`,
+        style: HANDLE_STYLE
+      },
+      `source-${position}`
+    ))
+  ] });
+}
+
+// src/nodes/shared/theme.ts
+var BPMN_THEME = {
+  fill: "#ffffff",
+  stroke: "#404040",
+  strokeSelected: "#1a56db",
+  strokeWidth: 1.5,
+  strokeWidthSelected: 2.5,
+  fontFamily: "Inter, system-ui, sans-serif",
+  fontSize: 11,
+  labelColor: "#1a1a1a"};
+function resolveStroke(selected, override) {
+  if (selected) return BPMN_THEME.strokeSelected;
+  return override ?? BPMN_THEME.stroke;
+}
+function resolveStrokeWidth(selected) {
+  return selected ? BPMN_THEME.strokeWidthSelected : BPMN_THEME.strokeWidth;
+}
+var EXTERNAL_STYLE = {
+  position: "absolute",
+  top: "100%",
+  left: "50%",
+  transform: "translateX(-50%)",
+  marginTop: 4,
+  fontSize: BPMN_THEME.fontSize,
+  fontFamily: BPMN_THEME.fontFamily,
+  color: BPMN_THEME.labelColor,
+  textAlign: "center",
+  whiteSpace: "nowrap",
+  maxWidth: 100,
+  overflow: "hidden",
+  textOverflow: "ellipsis",
+  pointerEvents: "none",
+  lineHeight: 1.3
+};
+var INTERNAL_STYLE = {
+  fontSize: BPMN_THEME.fontSize,
+  fontFamily: BPMN_THEME.fontFamily,
+  color: BPMN_THEME.labelColor,
+  textAlign: "center",
+  lineHeight: 1.3,
+  overflow: "hidden",
+  wordBreak: "break-word"
+};
+function BpmnLabel({ children, external = false, style }) {
+  if (!children) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { style: { ...external ? EXTERNAL_STYLE : INTERNAL_STYLE, ...style }, children });
+}
+function pentagon(r) {
+  const pts = Array.from({ length: 5 }, (_, i) => {
+    const a = (i * 72 - 90) * (Math.PI / 180);
+    return `${(r * Math.cos(a)).toFixed(2)},${(r * Math.sin(a)).toFixed(2)}`;
+  });
+  return `M ${pts.join(" L ")} Z`;
+}
+function EventMarker({ cx, cy, trigger, filled = false, stroke, bg, r = 10 }) {
+  const s = r * 0.6;
+  const f = filled ? stroke : "none";
+  const sw = 1.4;
+  if (trigger === "none" || !trigger) return null;
+  return /* @__PURE__ */ jsxRuntime.jsxs("g", { transform: `translate(${cx},${cy})`, strokeLinecap: "round", strokeLinejoin: "round", children: [
+    trigger === "message" && /* @__PURE__ */ jsxRuntime.jsxs("g", { fill: f, stroke, strokeWidth: sw, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("rect", { x: -s, y: -s * 0.65, width: s * 2, height: s * 1.3, rx: 0.5 }),
+      /* @__PURE__ */ jsxRuntime.jsx("polyline", { fill: "none", points: `${-s},${-s * 0.65} 0,${s * 0.2} ${s},${-s * 0.65}` })
+    ] }),
+    trigger === "timer" && /* @__PURE__ */ jsxRuntime.jsxs("g", { fill: f, stroke, strokeWidth: sw, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("circle", { r: s, fill: bg, stroke, strokeWidth: sw }),
+      Array.from({ length: 12 }, (_, i) => {
+        const a = (i * 30 - 90) * (Math.PI / 180);
+        const len = i % 3 === 0 ? 0.25 : 0.15;
+        const x1 = Math.cos(a) * s * 0.75;
+        const y1 = Math.sin(a) * s * 0.75;
+        const x2 = Math.cos(a) * s * (0.75 + len);
+        const y2 = Math.sin(a) * s * (0.75 + len);
+        return /* @__PURE__ */ jsxRuntime.jsx("line", { x1, y1, x2, y2, stroke, strokeWidth: sw * 0.8 }, i);
+      }),
+      /* @__PURE__ */ jsxRuntime.jsx("line", { x1: 0, y1: 0, x2: 0, y2: -s * 0.5, stroke, strokeWidth: sw }),
+      /* @__PURE__ */ jsxRuntime.jsx("line", { x1: 0, y1: 0, x2: s * 0.4, y2: 0, stroke, strokeWidth: sw })
+    ] }),
+    trigger === "error" && /* @__PURE__ */ jsxRuntime.jsx(
+      "path",
+      {
+        d: `M ${s * 0.35},${-s} L ${-s * 0.15},${-s * 0.05} L ${s * 0.35},${s * 0.05} L ${-s * 0.35},${s} L ${s * 0.15},${s * 0.05} L ${-s * 0.35},${-s * 0.05} Z`,
+        fill: f,
+        stroke,
+        strokeWidth: sw
+      }
+    ),
+    trigger === "escalation" && /* @__PURE__ */ jsxRuntime.jsx(
+      "path",
+      {
+        d: `M 0,${-s} L ${s * 0.8},${s * 0.7} L 0,${s * 0.2} L ${-s * 0.8},${s * 0.7} Z`,
+        fill: f,
+        stroke,
+        strokeWidth: sw
+      }
+    ),
+    trigger === "conditional" && // Three horizontal lines (document/list)
+    /* @__PURE__ */ jsxRuntime.jsxs("g", { stroke, strokeWidth: sw, fill: "none", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("rect", { x: -s * 0.75, y: -s * 0.9, width: s * 1.5, height: s * 1.8, rx: 1, fill: bg, stroke, strokeWidth: sw }),
+      /* @__PURE__ */ jsxRuntime.jsx("line", { x1: -s * 0.45, y1: -s * 0.4, x2: s * 0.45, y2: -s * 0.4 }),
+      /* @__PURE__ */ jsxRuntime.jsx("line", { x1: -s * 0.45, y1: 0, x2: s * 0.45, y2: 0 }),
+      /* @__PURE__ */ jsxRuntime.jsx("line", { x1: -s * 0.45, y1: s * 0.4, x2: s * 0.45, y2: s * 0.4 })
+    ] }),
+    trigger === "link" && // Arrow pointing right
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "path",
+      {
+        d: `M ${-s * 0.9},${-s * 0.35} L ${s * 0.1},${-s * 0.35} L ${s * 0.1},${-s * 0.65} L ${s},0 L ${s * 0.1},${s * 0.65} L ${s * 0.1},${s * 0.35} L ${-s * 0.9},${s * 0.35} Z`,
+        fill: f,
+        stroke,
+        strokeWidth: sw
+      }
+    ),
+    trigger === "compensation" && // Two left-pointing chevrons <<
+    /* @__PURE__ */ jsxRuntime.jsxs("g", { fill: f, stroke, strokeWidth: sw, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "polyline",
+        {
+          fill: f,
+          strokeLinejoin: "round",
+          points: `${s * 0.5},${-s * 0.7} ${-s * 0.1},0 ${s * 0.5},${s * 0.7}`
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "polyline",
+        {
+          fill: f,
+          strokeLinejoin: "round",
+          points: `${s},${-s * 0.7} ${s * 0.4},0 ${s},${s * 0.7}`
+        }
+      ),
+      filled && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx("polygon", { fill: stroke, points: `${s * 0.5},${-s * 0.7} ${-s * 0.1},0 ${s * 0.5},${s * 0.7}` }),
+        /* @__PURE__ */ jsxRuntime.jsx("polygon", { fill: stroke, points: `${s},${-s * 0.7} ${s * 0.4},0 ${s},${s * 0.7}` })
+      ] })
+    ] }),
+    trigger === "signal" && /* @__PURE__ */ jsxRuntime.jsx(
+      "polygon",
+      {
+        points: `0,${-s} ${s * 0.9},${s * 0.7} ${-s * 0.9},${s * 0.7}`,
+        fill: f,
+        stroke,
+        strokeWidth: sw
+      }
+    ),
+    trigger === "cancel" && // X mark
+    /* @__PURE__ */ jsxRuntime.jsxs("g", { stroke, strokeWidth: sw * 1.5, strokeLinecap: "round", fill: "none", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("line", { x1: -s * 0.7, y1: -s * 0.7, x2: s * 0.7, y2: s * 0.7 }),
+      /* @__PURE__ */ jsxRuntime.jsx("line", { x1: s * 0.7, y1: -s * 0.7, x2: -s * 0.7, y2: s * 0.7 })
+    ] }),
+    trigger === "terminate" && /* @__PURE__ */ jsxRuntime.jsx("circle", { r: s * 0.8, fill: stroke, stroke, strokeWidth: sw }),
+    trigger === "multiple" && /* @__PURE__ */ jsxRuntime.jsx("path", { d: pentagon(s * 0.9), fill: f, stroke, strokeWidth: sw }),
+    trigger === "parallelMultiple" && /* @__PURE__ */ jsxRuntime.jsxs("g", { stroke, strokeWidth: sw * 1.5, strokeLinecap: "round", fill: "none", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("line", { x1: 0, y1: -s * 0.8, x2: 0, y2: s * 0.8 }),
+      /* @__PURE__ */ jsxRuntime.jsx("line", { x1: -s * 0.8, y1: 0, x2: s * 0.8, y2: 0 })
+    ] })
+  ] });
+}
+var SIZE = 36;
+var CX = SIZE / 2;
+var R = CX - 2;
+function StartEventNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  const fill = d.color?.fill ?? BPMN_THEME.fill;
+  const trigger = d.trigger ?? "none";
+  const dashArray = d.isNonInterrupting ? "4 2" : void 0;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { width: SIZE, height: SIZE, position: "relative" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: SIZE, height: SIZE, style: { overflow: "visible", display: "block" }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "circle",
+        {
+          cx: CX,
+          cy: CX,
+          r: R,
+          fill,
+          stroke,
+          strokeWidth: sw,
+          strokeDasharray: dashArray
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(EventMarker, { cx: CX, cy: CX, trigger, filled: false, stroke, bg: fill, r: R * 0.55 })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnHandles, { variant: "source" }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnLabel, { external: true, children: d.label })
+  ] });
+}
+var SIZE2 = 36;
+var CX2 = SIZE2 / 2;
+var R2 = CX2 - 2;
+function EndEventNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  const fill = d.color?.fill ?? BPMN_THEME.fill;
+  const trigger = d.trigger ?? "none";
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { width: SIZE2, height: SIZE2, position: "relative" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: SIZE2, height: SIZE2, style: { overflow: "visible", display: "block" }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "circle",
+        {
+          cx: CX2,
+          cy: CX2,
+          r: R2,
+          fill,
+          stroke,
+          strokeWidth: sw + 2
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(EventMarker, { cx: CX2, cy: CX2, trigger, filled: true, stroke, bg: fill, r: R2 * 0.55 })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnHandles, { variant: "target" }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnLabel, { external: true, children: d.label })
+  ] });
+}
+var SIZE3 = 36;
+var CX3 = SIZE3 / 2;
+var R_OUTER = CX3 - 2;
+var R_INNER = R_OUTER - 3;
+var ICON_R = R_INNER * 0.65;
+function IntermediateCatchEventNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  const fill = d.color?.fill ?? BPMN_THEME.fill;
+  const trigger = d.trigger ?? "none";
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { width: SIZE3, height: SIZE3, position: "relative" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: SIZE3, height: SIZE3, style: { overflow: "visible", display: "block" }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: CX3, cy: CX3, r: R_OUTER, fill, stroke, strokeWidth: sw }),
+      /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: CX3, cy: CX3, r: R_INNER, fill: "none", stroke, strokeWidth: sw }),
+      /* @__PURE__ */ jsxRuntime.jsx(EventMarker, { cx: CX3, cy: CX3, trigger, filled: false, stroke, bg: fill, r: ICON_R })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnHandles, { variant: "all" }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnLabel, { external: true, children: d.label })
+  ] });
+}
+function IntermediateThrowEventNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  const fill = d.color?.fill ?? BPMN_THEME.fill;
+  const trigger = d.trigger ?? "none";
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { width: SIZE3, height: SIZE3, position: "relative" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: SIZE3, height: SIZE3, style: { overflow: "visible", display: "block" }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: CX3, cy: CX3, r: R_OUTER, fill, stroke, strokeWidth: sw }),
+      /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: CX3, cy: CX3, r: R_INNER, fill: stroke, stroke, strokeWidth: sw }),
+      /* @__PURE__ */ jsxRuntime.jsx(EventMarker, { cx: CX3, cy: CX3, trigger, filled: true, stroke: fill, bg: stroke, r: ICON_R })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnHandles, { variant: "all" }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnLabel, { external: true, children: d.label })
+  ] });
+}
+function BoundaryEventNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  const fill = d.color?.fill ?? BPMN_THEME.fill;
+  const trigger = d.trigger ?? "none";
+  const dashArray = d.isNonInterrupting ? "4 2" : void 0;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { width: SIZE3, height: SIZE3, position: "relative" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: SIZE3, height: SIZE3, style: { overflow: "visible", display: "block" }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "circle",
+        {
+          cx: CX3,
+          cy: CX3,
+          r: R_OUTER,
+          fill,
+          stroke,
+          strokeWidth: sw,
+          strokeDasharray: dashArray
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "circle",
+        {
+          cx: CX3,
+          cy: CX3,
+          r: R_INNER,
+          fill: "none",
+          stroke,
+          strokeWidth: sw,
+          strokeDasharray: dashArray
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(EventMarker, { cx: CX3, cy: CX3, trigger, filled: false, stroke, bg: fill, r: ICON_R })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnHandles, { variant: "source" }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnLabel, { external: true, children: d.label })
+  ] });
+}
+function TaskIcon({ type, size = 14, color = "#404040" }) {
+  const s = size;
+  const c = color;
+  switch (type) {
+    case "UserTask":
+      return /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: s, height: s, viewBox: "0 0 16 16", fill: "none", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "8", cy: "5", r: "3", stroke: c, strokeWidth: "1.5" }),
+        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M2 14c0-3.3 2.7-6 6-6s6 2.7 6 6", stroke: c, strokeWidth: "1.5", strokeLinecap: "round" })
+      ] });
+    case "ServiceTask":
+      return /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: s, height: s, viewBox: "0 0 16 16", fill: "none", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "8", cy: "8", r: "2.5", stroke: c, strokeWidth: "1.5" }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "path",
+          {
+            d: "M8 1v2M8 13v2M1 8h2M13 8h2M3.2 3.2l1.4 1.4M11.4 11.4l1.4 1.4M3.2 12.8l1.4-1.4M11.4 4.6l1.4-1.4",
+            stroke: c,
+            strokeWidth: "1.5",
+            strokeLinecap: "round"
+          }
+        )
+      ] });
+    case "ScriptTask":
+      return /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: s, height: s, viewBox: "0 0 16 16", fill: "none", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("rect", { x: "3", y: "2", width: "10", height: "12", rx: "1", stroke: c, strokeWidth: "1.5" }),
+        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M6 6h4M6 9h4M6 12h2", stroke: c, strokeWidth: "1.5", strokeLinecap: "round" })
+      ] });
+    case "ManualTask":
+      return /* @__PURE__ */ jsxRuntime.jsx("svg", { width: s, height: s, viewBox: "0 0 16 16", fill: "none", children: /* @__PURE__ */ jsxRuntime.jsx(
+        "path",
+        {
+          d: "M5 10V6a1 1 0 0 1 2 0v2a1 1 0 0 1 2 0v1a1 1 0 0 1 2 0v2c0 1.7-1.3 3-3 3H6a3 3 0 0 1-3-3V9.5",
+          stroke: c,
+          strokeWidth: "1.5",
+          strokeLinecap: "round",
+          strokeLinejoin: "round"
+        }
+      ) });
+    case "BusinessRuleTask":
+      return /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: s, height: s, viewBox: "0 0 16 16", fill: "none", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("rect", { x: "2", y: "3", width: "12", height: "10", rx: "1", stroke: c, strokeWidth: "1.5" }),
+        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M2 7h12M6 3v10", stroke: c, strokeWidth: "1.5" })
+      ] });
+    case "ReceiveTask":
+      return /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: s, height: s, viewBox: "0 0 16 16", fill: "none", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("rect", { x: "2", y: "4", width: "12", height: "8", rx: "1", stroke: c, strokeWidth: "1.5" }),
+        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M2 4l6 5 6-5", stroke: c, strokeWidth: "1.5", strokeLinecap: "round" })
+      ] });
+    case "SendTask":
+      return /* @__PURE__ */ jsxRuntime.jsx("svg", { width: s, height: s, viewBox: "0 0 16 16", fill: c, children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M2 4a1 1 0 0 1 1-1h10a1 1 0 0 1 1 1v8a1 1 0 0 1-1 1H3a1 1 0 0 1-1-1V4zm1 0l5 4.5L13 4H3z" }) });
+    case "CallActivity":
+      return /* @__PURE__ */ jsxRuntime.jsx("svg", { width: s, height: s, viewBox: "0 0 16 16", fill: "none", children: /* @__PURE__ */ jsxRuntime.jsx("rect", { x: "3", y: "5", width: "10", height: "6", rx: "1", stroke: c, strokeWidth: "2" }) });
+    default:
+      return null;
+  }
+}
+var MARKER_SIZE = 12;
+var GAP = 3;
+function TaskMarkers({ markers, stroke, size = MARKER_SIZE }) {
+  if (!markers || markers.length === 0) return null;
+  const total = markers.length * size + (markers.length - 1) * GAP;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      style: {
+        position: "absolute",
+        bottom: 5,
+        left: "50%",
+        transform: "translateX(-50%)",
+        display: "flex",
+        alignItems: "center",
+        gap: GAP,
+        width: total
+      },
+      children: markers.map((m) => /* @__PURE__ */ jsxRuntime.jsx(MarkerIcon, { marker: m, stroke, size }, m))
+    }
+  );
+}
+function MarkerIcon({ marker, stroke, size }) {
+  const s = size / 2;
+  const sw = 1.3;
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "svg",
+    {
+      width: size,
+      height: size,
+      viewBox: `${-s} ${-s} ${size} ${size}`,
+      style: { overflow: "visible", display: "block" },
+      children: [
+        marker === "loop" && // Circular arrow (↻)
+        /* @__PURE__ */ jsxRuntime.jsxs("g", { fill: "none", stroke, strokeWidth: sw, strokeLinecap: "round", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("path", { d: `M 0,${-s * 0.85} A ${s * 0.85},${s * 0.85} 0 1 1 ${s * 0.6},${s * 0.6}` }),
+          /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: `${s * 0.2},${s * 0.9} ${s * 0.6},${s * 0.6} ${s * 0.95},${s}` })
+        ] }),
+        marker === "parallelMultiple" && // Three vertical bars |||
+        /* @__PURE__ */ jsxRuntime.jsxs("g", { stroke, strokeWidth: sw, strokeLinecap: "round", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("line", { x1: -s * 0.55, y1: -s * 0.75, x2: -s * 0.55, y2: s * 0.75 }),
+          /* @__PURE__ */ jsxRuntime.jsx("line", { x1: 0, y1: -s * 0.75, x2: 0, y2: s * 0.75 }),
+          /* @__PURE__ */ jsxRuntime.jsx("line", { x1: s * 0.55, y1: -s * 0.75, x2: s * 0.55, y2: s * 0.75 })
+        ] }),
+        marker === "sequentialMultiple" && // Three horizontal bars ≡
+        /* @__PURE__ */ jsxRuntime.jsxs("g", { stroke, strokeWidth: sw, strokeLinecap: "round", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("line", { x1: -s * 0.75, y1: -s * 0.55, x2: s * 0.75, y2: -s * 0.55 }),
+          /* @__PURE__ */ jsxRuntime.jsx("line", { x1: -s * 0.75, y1: 0, x2: s * 0.75, y2: 0 }),
+          /* @__PURE__ */ jsxRuntime.jsx("line", { x1: -s * 0.75, y1: s * 0.55, x2: s * 0.75, y2: s * 0.55 })
+        ] }),
+        marker === "compensation" && // Two left-pointing triangles <<
+        /* @__PURE__ */ jsxRuntime.jsxs("g", { fill: stroke, stroke, strokeWidth: 0.5, strokeLinejoin: "round", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("polygon", { points: `${s * 0.4},${-s * 0.7} ${-s * 0.2},0 ${s * 0.4},${s * 0.7}` }),
+          /* @__PURE__ */ jsxRuntime.jsx("polygon", { points: `${s},${-s * 0.7} ${s * 0.4},0 ${s},${s * 0.7}` })
+        ] })
+      ]
+    }
+  );
+}
+function AdhocMarker({ stroke, size = MARKER_SIZE }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      style: {
+        position: "absolute",
+        bottom: 5,
+        left: "50%",
+        transform: "translateX(-50%)",
+        color: stroke,
+        fontSize: size,
+        lineHeight: 1,
+        fontFamily: "serif",
+        userSelect: "none"
+      },
+      children: "~"
+    }
+  );
+}
+function TaskNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  const hasMarkers = d.markers && d.markers.length > 0;
+  const borderWidth = d.elementType === "CallActivity" ? sw + 2 : sw;
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      style: {
+        width: "100%",
+        height: "100%",
+        background: d.color?.fill ?? BPMN_THEME.fill,
+        border: `${borderWidth}px solid ${stroke}`,
+        borderRadius: 6,
+        boxSizing: "border-box",
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        justifyContent: "center",
+        padding: hasMarkers ? "4px 8px 22px" : "4px 8px",
+        position: "relative",
+        fontFamily: BPMN_THEME.fontFamily
+      },
+      children: [
+        d.elementType && d.elementType !== "Task" && /* @__PURE__ */ jsxRuntime.jsx("div", { style: { position: "absolute", top: 5, left: 5 }, children: /* @__PURE__ */ jsxRuntime.jsx(TaskIcon, { type: d.elementType, size: 14, color: stroke }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(BpmnLabel, { style: { width: "100%" }, children: d.label ?? d.elementType }),
+        d.priority && /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            title: d.priority,
+            style: {
+              position: "absolute",
+              top: 5,
+              right: 5,
+              width: 8,
+              height: 8,
+              borderRadius: "50%",
+              background: PRIORITY_COLOR[d.priority]
+            }
+          }
+        ),
+        hasMarkers && /* @__PURE__ */ jsxRuntime.jsx(TaskMarkers, { markers: d.markers, stroke }),
+        /* @__PURE__ */ jsxRuntime.jsx(BpmnHandles, { variant: "all" })
+      ]
+    }
+  );
+}
+var PRIORITY_COLOR = {
+  critical: "#ef4444",
+  high: "#f97316",
+  medium: "#eab308",
+  low: "#22c55e"
+};
+var SIZE4 = 50;
+var H = SIZE4 / 2;
+var DIAMOND = `${H},2 ${SIZE4 - 2},${H} ${H},${SIZE4 - 2} 2,${H}`;
+function GatewaySymbol({ type, stroke }) {
+  const c = H;
+  switch (type) {
+    case "ExclusiveGateway":
+      return /* @__PURE__ */ jsxRuntime.jsxs("g", { stroke, strokeWidth: "2.5", strokeLinecap: "round", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: c - 7, y1: c - 7, x2: c + 7, y2: c + 7 }),
+        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: c + 7, y1: c - 7, x2: c - 7, y2: c + 7 })
+      ] });
+    case "InclusiveGateway":
+      return /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: c, cy: c, r: 8, fill: "none", stroke, strokeWidth: "2" });
+    case "ParallelGateway":
+      return /* @__PURE__ */ jsxRuntime.jsxs("g", { stroke, strokeWidth: "2.5", strokeLinecap: "round", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: c, y1: c - 9, x2: c, y2: c + 9 }),
+        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: c - 9, y1: c, x2: c + 9, y2: c })
+      ] });
+    case "EventBasedGateway":
+      return /* @__PURE__ */ jsxRuntime.jsxs("g", { children: [
+        /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: c, cy: c, r: 9, fill: "none", stroke, strokeWidth: "1.5" }),
+        /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: c, cy: c, r: 6, fill: "none", stroke, strokeWidth: "1.2" }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "polygon",
+          {
+            points: `${c},${c - 5.5} ${c + 5.2},${c - 1.7} ${c + 3.2},${c + 4.8} ${c - 3.2},${c + 4.8} ${c - 5.2},${c - 1.7}`,
+            fill: "none",
+            stroke,
+            strokeWidth: "1.4",
+            strokeLinejoin: "round"
+          }
+        )
+      ] });
+    case "ComplexGateway":
+      return /* @__PURE__ */ jsxRuntime.jsxs("g", { stroke, strokeWidth: "2", strokeLinecap: "round", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: c, y1: c - 9, x2: c, y2: c + 9 }),
+        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: c - 9, y1: c, x2: c + 9, y2: c }),
+        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: c - 6, y1: c - 6, x2: c + 6, y2: c + 6 }),
+        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: c + 6, y1: c - 6, x2: c - 6, y2: c + 6 })
+      ] });
+    default:
+      return null;
+  }
+}
+function GatewayNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { width: SIZE4, height: SIZE4, position: "relative" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: SIZE4, height: SIZE4, style: { overflow: "visible", display: "block" }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "polygon",
+        {
+          points: DIAMOND,
+          fill: d.color?.fill ?? BPMN_THEME.fill,
+          stroke,
+          strokeWidth: sw
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(GatewaySymbol, { type: d.elementType, stroke })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnHandles, { variant: "all" }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnLabel, { external: true, children: d.label })
+  ] });
+}
+function SubProcessNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  const variant = d.subProcessVariant ?? "embedded";
+  const isExpanded = d.isExpanded ?? true;
+  const hasMarkers = d.markers && d.markers.length > 0;
+  const borderStyle = variant === "event" ? "dashed" : "solid";
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      style: {
+        width: "100%",
+        height: "100%",
+        background: d.color?.fill ?? "#f8faff",
+        border: `${sw}px ${borderStyle} ${stroke}`,
+        borderRadius: 6,
+        boxSizing: "border-box",
+        position: "relative",
+        fontFamily: BPMN_THEME.fontFamily
+      },
+      children: [
+        variant === "transaction" && /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              inset: 4,
+              border: `${sw}px solid ${stroke}`,
+              borderRadius: 4,
+              pointerEvents: "none"
+            }
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(BpmnLabel, { style: { padding: "4px 8px" }, children: d.label }),
+        !isExpanded && /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            "aria-label": "collapsed-subprocess-marker",
+            style: {
+              position: "absolute",
+              bottom: 6,
+              left: "50%",
+              transform: "translateX(-50%)",
+              width: 16,
+              height: 16,
+              border: `1.5px solid ${stroke}`,
+              borderRadius: 2,
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              fontSize: 12,
+              color: stroke,
+              background: BPMN_THEME.fill,
+              zIndex: 1
+            },
+            children: "+"
+          }
+        ),
+        variant === "adhoc" && /* @__PURE__ */ jsxRuntime.jsx(AdhocMarker, { stroke }),
+        hasMarkers && /* @__PURE__ */ jsxRuntime.jsx(TaskMarkers, { markers: d.markers, stroke }),
+        /* @__PURE__ */ jsxRuntime.jsx(BpmnHandles, { variant: "all" })
+      ]
+    }
+  );
+}
+var HEADER_WIDTH = 30;
+var HEADER_HEIGHT = 28;
+function PoolNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  const orientation = d.orientation ?? "horizontal";
+  const fill = d.color?.fill ?? "#f5f7ff";
+  const headerFill = d.color?.fill ?? "#edf0ff";
+  if (orientation === "vertical") {
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        style: {
+          width: "100%",
+          height: "100%",
+          display: "flex",
+          flexDirection: "column",
+          border: `${sw}px solid ${stroke}`,
+          borderRadius: 4,
+          boxSizing: "border-box",
+          background: fill,
+          overflow: "hidden",
+          fontFamily: BPMN_THEME.fontFamily
+        },
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "div",
+            {
+              "aria-label": "pool-header",
+              style: {
+                height: HEADER_HEIGHT,
+                minHeight: HEADER_HEIGHT,
+                borderBottom: `${sw}px solid ${stroke}`,
+                display: "flex",
+                alignItems: "center",
+                justifyContent: "center",
+                background: headerFill,
+                padding: "0 8px"
+              },
+              children: /* @__PURE__ */ jsxRuntime.jsx(
+                "span",
+                {
+                  style: {
+                    fontSize: BPMN_THEME.fontSize,
+                    fontWeight: 600,
+                    color: BPMN_THEME.labelColor,
+                    whiteSpace: "nowrap",
+                    overflow: "hidden",
+                    textOverflow: "ellipsis"
+                  },
+                  children: d.label
+                }
+              )
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { style: { flex: 1, position: "relative" } })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      style: {
+        width: "100%",
+        height: "100%",
+        display: "flex",
+        border: `${sw}px solid ${stroke}`,
+        borderRadius: 4,
+        boxSizing: "border-box",
+        background: fill,
+        overflow: "hidden",
+        fontFamily: BPMN_THEME.fontFamily
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            "aria-label": "pool-header",
+            style: {
+              width: HEADER_WIDTH,
+              minWidth: HEADER_WIDTH,
+              borderRight: `${sw}px solid ${stroke}`,
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              background: headerFill
+            },
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              "span",
+              {
+                style: {
+                  writingMode: "vertical-rl",
+                  transform: "rotate(180deg)",
+                  fontSize: BPMN_THEME.fontSize,
+                  fontWeight: 600,
+                  color: BPMN_THEME.labelColor,
+                  whiteSpace: "nowrap",
+                  overflow: "hidden",
+                  textOverflow: "ellipsis",
+                  maxHeight: "90%"
+                },
+                children: d.label
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { style: { flex: 1, position: "relative" } })
+      ]
+    }
+  );
+}
+var HEADER_HEIGHT2 = 24;
+var HEADER_WIDTH2 = 28;
+function LaneNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  const orientation = d.orientation ?? "horizontal";
+  const fill = d.color?.fill ?? "#fafbff";
+  const headerFill = d.color?.fill ?? "#f0f3ff";
+  if (orientation === "vertical") {
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        style: {
+          width: "100%",
+          height: "100%",
+          display: "flex",
+          border: `${sw}px solid ${stroke}`,
+          borderRadius: 2,
+          boxSizing: "border-box",
+          background: fill,
+          overflow: "hidden",
+          fontFamily: BPMN_THEME.fontFamily
+        },
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "div",
+            {
+              "aria-label": "lane-header",
+              style: {
+                width: HEADER_WIDTH2,
+                minWidth: HEADER_WIDTH2,
+                borderRight: `1px solid ${stroke}`,
+                display: "flex",
+                alignItems: "center",
+                justifyContent: "center",
+                background: headerFill,
+                padding: "6px 0"
+              },
+              children: /* @__PURE__ */ jsxRuntime.jsx(
+                "span",
+                {
+                  style: {
+                    writingMode: "vertical-rl",
+                    transform: "rotate(180deg)",
+                    fontSize: BPMN_THEME.fontSize,
+                    fontWeight: 500,
+                    color: BPMN_THEME.labelColor,
+                    whiteSpace: "nowrap",
+                    overflow: "hidden",
+                    textOverflow: "ellipsis",
+                    maxHeight: "90%"
+                  },
+                  children: d.label
+                }
+              )
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { style: { flex: 1, position: "relative" } })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      style: {
+        width: "100%",
+        height: "100%",
+        display: "flex",
+        flexDirection: "column",
+        border: `${sw}px solid ${stroke}`,
+        borderRadius: 2,
+        boxSizing: "border-box",
+        background: fill,
+        overflow: "hidden",
+        fontFamily: BPMN_THEME.fontFamily
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            "aria-label": "lane-header",
+            style: {
+              height: HEADER_HEIGHT2,
+              minHeight: HEADER_HEIGHT2,
+              borderBottom: `1px solid ${stroke}`,
+              display: "flex",
+              alignItems: "center",
+              paddingLeft: 8,
+              background: headerFill,
+              fontSize: BPMN_THEME.fontSize,
+              fontWeight: 500,
+              color: BPMN_THEME.labelColor
+            },
+            children: d.label
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { style: { flex: 1, position: "relative" } })
+      ]
+    }
+  );
+}
+var HANDLE_STYLE2 = { opacity: 0, width: 6, height: 6 };
+function AnnotationNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  const orientation = d.orientation ?? "vertical";
+  if (orientation === "horizontal") {
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        style: {
+          width: "100%",
+          height: "100%",
+          boxSizing: "border-box",
+          borderTop: `${sw + 1}px solid ${stroke}`,
+          borderLeft: `${sw}px solid ${stroke}`,
+          borderRight: `${sw}px solid ${stroke}`,
+          padding: "8px 6px",
+          background: "transparent",
+          fontFamily: BPMN_THEME.fontFamily,
+          fontSize: BPMN_THEME.fontSize,
+          color: BPMN_THEME.labelColor,
+          lineHeight: 1.4
+        },
+        children: [
+          d.label,
+          /* @__PURE__ */ jsxRuntime.jsx(react.Handle, { type: "target", position: react.Position.Left, id: "target-left", style: HANDLE_STYLE2 }),
+          /* @__PURE__ */ jsxRuntime.jsx(react.Handle, { type: "target", position: react.Position.Right, id: "target-right", style: HANDLE_STYLE2 }),
+          /* @__PURE__ */ jsxRuntime.jsx(react.Handle, { type: "source", position: react.Position.Left, id: "source-left", style: HANDLE_STYLE2 }),
+          /* @__PURE__ */ jsxRuntime.jsx(react.Handle, { type: "source", position: react.Position.Right, id: "source-right", style: HANDLE_STYLE2 })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      style: {
+        width: "100%",
+        height: "100%",
+        boxSizing: "border-box",
+        borderLeft: `${sw + 1}px solid ${stroke}`,
+        borderTop: `${sw}px solid ${stroke}`,
+        borderBottom: `${sw}px solid ${stroke}`,
+        padding: "4px 8px",
+        background: "transparent",
+        fontFamily: BPMN_THEME.fontFamily,
+        fontSize: BPMN_THEME.fontSize,
+        color: BPMN_THEME.labelColor,
+        lineHeight: 1.4
+      },
+      children: [
+        d.label,
+        /* @__PURE__ */ jsxRuntime.jsx(react.Handle, { type: "target", position: react.Position.Top, id: "target-top", style: HANDLE_STYLE2 }),
+        /* @__PURE__ */ jsxRuntime.jsx(react.Handle, { type: "target", position: react.Position.Bottom, id: "target-bottom", style: HANDLE_STYLE2 }),
+        /* @__PURE__ */ jsxRuntime.jsx(react.Handle, { type: "source", position: react.Position.Top, id: "source-top", style: HANDLE_STYLE2 }),
+        /* @__PURE__ */ jsxRuntime.jsx(react.Handle, { type: "source", position: react.Position.Bottom, id: "source-bottom", style: HANDLE_STYLE2 })
+      ]
+    }
+  );
+}
+function GroupNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      style: {
+        width: "100%",
+        height: "100%",
+        border: `${sw}px dashed ${stroke}`,
+        borderRadius: 8,
+        boxSizing: "border-box",
+        background: "transparent",
+        padding: "4px 8px",
+        fontFamily: BPMN_THEME.fontFamily,
+        fontSize: BPMN_THEME.fontSize,
+        color: BPMN_THEME.labelColor,
+        fontStyle: "italic"
+      },
+      children: d.label
+    }
+  );
+}
+var W = 36;
+var H2 = 50;
+var FOLD = 10;
+function DataObjectNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  const fill = d.color?.fill ?? BPMN_THEME.fill;
+  const path = [
+    `M 0 0`,
+    `L ${W - FOLD} 0`,
+    `L ${W} ${FOLD}`,
+    `L ${W} ${H2}`,
+    `L 0 ${H2}`,
+    `Z`
+  ].join(" ");
+  const foldPath2 = [
+    `M ${W - FOLD} 0`,
+    `L ${W - FOLD} ${FOLD}`,
+    `L ${W} ${FOLD}`
+  ].join(" ");
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { width: W, height: H2, position: "relative" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: W, height: H2, style: { overflow: "visible", display: "block" }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("path", { d: path, fill, stroke, strokeWidth: sw }),
+      /* @__PURE__ */ jsxRuntime.jsx("path", { d: foldPath2, fill: "none", stroke, strokeWidth: sw })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnHandles, { variant: "all" }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnLabel, { external: true, children: d.label })
+  ] });
+}
+var DS_W = 50;
+var DS_H = 50;
+var RX = DS_W / 2;
+var RY = 7;
+function DataStoreNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  const fill = d.color?.fill ?? BPMN_THEME.fill;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { width: DS_W, height: DS_H, position: "relative" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: DS_W, height: DS_H, style: { overflow: "visible", display: "block" }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "path",
+        {
+          d: `M 0 ${RY} Q 0 0 ${RX} 0 Q ${DS_W} 0 ${DS_W} ${RY} L ${DS_W} ${DS_H - RY} Q ${DS_W} ${DS_H} ${RX} ${DS_H} Q 0 ${DS_H} 0 ${DS_H - RY} Z`,
+          fill,
+          stroke,
+          strokeWidth: sw
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("ellipse", { cx: RX, cy: RY, rx: RX, ry: RY, fill, stroke, strokeWidth: sw })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnHandles, { variant: "all" }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnLabel, { external: true, children: d.label })
+  ] });
+}
+var W2 = 36;
+var H3 = 50;
+var FOLD2 = 10;
+function documentPath() {
+  return [
+    `M 0 0`,
+    `L ${W2 - FOLD2} 0`,
+    `L ${W2} ${FOLD2}`,
+    `L ${W2} ${H3}`,
+    `L 0 ${H3}`,
+    `Z`
+  ].join(" ");
+}
+function foldPath() {
+  return [`M ${W2 - FOLD2} 0`, `L ${W2 - FOLD2} ${FOLD2}`, `L ${W2} ${FOLD2}`].join(" ");
+}
+function collectionLines(stroke, sw) {
+  const y = H3 - 8;
+  return /* @__PURE__ */ jsxRuntime.jsxs("g", { stroke, strokeWidth: sw * 0.7, strokeLinecap: "round", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("line", { x1: W2 * 0.25, y1: y, x2: W2 * 0.75, y2: y }),
+    /* @__PURE__ */ jsxRuntime.jsx("line", { x1: W2 * 0.25, y1: y + 3, x2: W2 * 0.75, y2: y + 3 }),
+    /* @__PURE__ */ jsxRuntime.jsx("line", { x1: W2 * 0.25, y1: y + 6, x2: W2 * 0.75, y2: y + 6 })
+  ] });
+}
+function DataObjectReferenceNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  const fill = d.color?.fill ?? BPMN_THEME.fill;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { width: W2, height: H3, position: "relative" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: W2, height: H3, style: { overflow: "visible", display: "block" }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("path", { d: documentPath(), fill, stroke, strokeWidth: sw }),
+      /* @__PURE__ */ jsxRuntime.jsx("path", { d: foldPath(), fill: "none", stroke, strokeWidth: sw }),
+      d.isCollection && collectionLines(stroke, sw)
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnHandles, { variant: "all" }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnLabel, { external: true, children: d.label })
+  ] });
+}
+function DataInputNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  const fill = d.color?.fill ?? BPMN_THEME.fill;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { width: W2, height: H3, position: "relative" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: W2, height: H3, style: { overflow: "visible", display: "block" }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("path", { d: documentPath(), fill, stroke, strokeWidth: sw }),
+      /* @__PURE__ */ jsxRuntime.jsx("path", { d: foldPath(), fill: "none", stroke, strokeWidth: sw }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "polygon",
+        {
+          points: `2,4 8,8 2,12`,
+          fill: "none",
+          stroke,
+          strokeWidth: sw * 0.8
+        }
+      ),
+      d.isCollection && collectionLines(stroke, sw)
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnHandles, { variant: "target" }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnLabel, { external: true, children: d.label })
+  ] });
+}
+function DataOutputNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  const fill = d.color?.fill ?? BPMN_THEME.fill;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { width: W2, height: H3, position: "relative" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: W2, height: H3, style: { overflow: "visible", display: "block" }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("path", { d: documentPath(), fill, stroke, strokeWidth: sw }),
+      /* @__PURE__ */ jsxRuntime.jsx("path", { d: foldPath(), fill: "none", stroke, strokeWidth: sw }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "polygon",
+        {
+          points: `2,4 8,8 2,12`,
+          fill: stroke,
+          stroke,
+          strokeWidth: sw * 0.8
+        }
+      ),
+      d.isCollection && collectionLines(stroke, sw)
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnHandles, { variant: "source" }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnLabel, { external: true, children: d.label })
+  ] });
+}
+var DS_W2 = 50;
+var DS_H2 = 50;
+var RX2 = DS_W2 / 2;
+var RY2 = 7;
+function DataStoreReferenceNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  const fill = d.color?.fill ?? BPMN_THEME.fill;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { width: DS_W2, height: DS_H2, position: "relative" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: DS_W2, height: DS_H2, style: { overflow: "visible", display: "block" }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "path",
+        {
+          d: `M 0 ${RY2} Q 0 0 ${RX2} 0 Q ${DS_W2} 0 ${DS_W2} ${RY2} L ${DS_W2} ${DS_H2 - RY2} Q ${DS_W2} ${DS_H2} ${RX2} ${DS_H2} Q 0 ${DS_H2} 0 ${DS_H2 - RY2} Z`,
+          fill,
+          stroke,
+          strokeWidth: sw
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("ellipse", { cx: RX2, cy: RY2, rx: RX2, ry: RY2, fill, stroke, strokeWidth: sw })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnHandles, { variant: "all" }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnLabel, { external: true, children: d.label })
+  ] });
+}
+var W3 = 60;
+var H4 = 52;
+var INDENT = W3 / 4;
+function hexPoints() {
+  return [
+    `0,${H4 / 2}`,
+    `${INDENT},0`,
+    `${W3 - INDENT},0`,
+    `${W3},${H4 / 2}`,
+    `${W3 - INDENT},${H4}`,
+    `${INDENT},${H4}`
+  ].join(" ");
+}
+function HexShell({
+  fill,
+  stroke,
+  sw,
+  thick = false
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "polygon",
+    {
+      points: hexPoints(),
+      fill,
+      stroke,
+      strokeWidth: thick ? sw + 2 : sw
+    }
+  );
+}
+function ConversationNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  const fill = d.color?.fill ?? BPMN_THEME.fill;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { width: W3, height: H4, position: "relative" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("svg", { width: W3, height: H4, style: { overflow: "visible", display: "block" }, children: /* @__PURE__ */ jsxRuntime.jsx(HexShell, { fill, stroke, sw }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnHandles, { variant: "all" }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnLabel, { style: { textAlign: "center" }, children: d.label })
+  ] });
+}
+function SubConversationNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  const fill = d.color?.fill ?? BPMN_THEME.fill;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { width: W3, height: H4, position: "relative" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: W3, height: H4, style: { overflow: "visible", display: "block" }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(HexShell, { fill, stroke, sw }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "rect",
+        {
+          x: W3 / 2 - 7,
+          y: H4 - 15,
+          width: 14,
+          height: 12,
+          rx: 2,
+          fill,
+          stroke,
+          strokeWidth: sw * 0.8
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("text", { x: W3 / 2, y: H4 - 6, textAnchor: "middle", fontSize: 10, fill: stroke, fontFamily: BPMN_THEME.fontFamily, children: "+" })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnHandles, { variant: "all" }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnLabel, { style: { textAlign: "center" }, children: d.label })
+  ] });
+}
+function CallConversationNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  const fill = d.color?.fill ?? BPMN_THEME.fill;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { width: W3, height: H4, position: "relative" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: W3, height: H4, style: { overflow: "visible", display: "block" }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(HexShell, { fill, stroke, sw, thick: true }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "rect",
+        {
+          x: W3 / 2 - 7,
+          y: H4 - 15,
+          width: 14,
+          height: 12,
+          rx: 2,
+          fill,
+          stroke,
+          strokeWidth: sw * 0.8
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("text", { x: W3 / 2, y: H4 - 6, textAnchor: "middle", fontSize: 10, fill: stroke, fontFamily: BPMN_THEME.fontFamily, children: "+" })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnHandles, { variant: "all" }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnLabel, { style: { textAlign: "center" }, children: d.label })
+  ] });
+}
+var BAND_H = 20;
+var RADIUS = 6;
+function ChoreographyShell({ d, stroke, sw, thick = false, collapsed = false }) {
+  const participants = d.participants ?? [
+    { name: "Initiator", isInitiating: true },
+    { name: "Responder", isInitiating: false }
+  ];
+  const fill = d.color?.fill ?? BPMN_THEME.fill;
+  const respondFill = "#c8d8e8";
+  const bw = thick ? sw + 2 : sw;
+  const [topParticipant, ...rest] = participants;
+  const bottomParticipants = rest;
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "rect",
+      {
+        x: 0,
+        y: 0,
+        width: "100%",
+        height: BAND_H,
+        fill: topParticipant.isInitiating ? fill : respondFill,
+        stroke,
+        strokeWidth: bw,
+        rx: RADIUS,
+        ry: RADIUS
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "rect",
+      {
+        x: 0,
+        y: BAND_H / 2,
+        width: "100%",
+        height: BAND_H / 2,
+        fill: topParticipant.isInitiating ? fill : respondFill,
+        stroke: "none"
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "rect",
+      {
+        x: 0,
+        y: BAND_H,
+        width: "100%",
+        height: `calc(100% - ${BAND_H * (1 + bottomParticipants.length)}px)`,
+        fill,
+        stroke,
+        strokeWidth: bw
+      }
+    ),
+    bottomParticipants.map((p, i) => {
+      const y = `calc(100% - ${BAND_H * (bottomParticipants.length - i)}px)`;
+      return /* @__PURE__ */ jsxRuntime.jsx("g", { children: /* @__PURE__ */ jsxRuntime.jsx(
+        "rect",
+        {
+          x: 0,
+          y,
+          width: "100%",
+          height: BAND_H,
+          fill: p.isInitiating ? fill : respondFill,
+          stroke,
+          strokeWidth: bw
+        }
+      ) }, i);
+    }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "rect",
+      {
+        x: bw / 2,
+        y: bw / 2,
+        width: `calc(100% - ${bw}px)`,
+        height: `calc(100% - ${bw}px)`,
+        fill: "none",
+        stroke,
+        strokeWidth: bw,
+        rx: RADIUS,
+        ry: RADIUS
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "foreignObject",
+      {
+        x: 4,
+        y: BAND_H,
+        width: "calc(100% - 8px)",
+        height: `calc(100% - ${BAND_H * (1 + bottomParticipants.length)}px)`,
+        children: /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            style: {
+              width: "100%",
+              height: "100%",
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              fontSize: BPMN_THEME.fontSize,
+              fontFamily: BPMN_THEME.fontFamily,
+              color: stroke,
+              textAlign: "center",
+              padding: "2px 4px",
+              boxSizing: "border-box",
+              overflow: "hidden"
+            },
+            children: d.label ?? ""
+          }
+        )
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "text",
+      {
+        x: "50%",
+        y: BAND_H * 0.65,
+        textAnchor: "middle",
+        fontSize: BPMN_THEME.fontSize - 1,
+        fontFamily: BPMN_THEME.fontFamily,
+        fill: stroke,
+        clipPath: void 0,
+        children: topParticipant.name
+      }
+    ),
+    bottomParticipants.map((p, i) => /* @__PURE__ */ jsxRuntime.jsx(
+      "text",
+      {
+        x: "50%",
+        y: `calc(100% - ${BAND_H * (bottomParticipants.length - i) - BAND_H * 0.35}px)`,
+        textAnchor: "middle",
+        fontSize: BPMN_THEME.fontSize - 1,
+        fontFamily: BPMN_THEME.fontFamily,
+        fill: stroke,
+        children: p.name
+      },
+      i
+    )),
+    collapsed && /* @__PURE__ */ jsxRuntime.jsxs("g", { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "rect",
+        {
+          x: "50%",
+          y: "calc(100% - 22px)",
+          width: 14,
+          height: 12,
+          transform: "translate(-7, 0)",
+          rx: 2,
+          fill,
+          stroke,
+          strokeWidth: sw * 0.8
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "text",
+        {
+          x: "50%",
+          y: "calc(100% - 13px)",
+          textAnchor: "middle",
+          fontSize: 10,
+          fill: stroke,
+          fontFamily: BPMN_THEME.fontFamily,
+          children: "+"
+        }
+      )
+    ] })
+  ] });
+}
+function ChoreographyTaskNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { width: "100%", height: "100%", position: "relative" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("svg", { width: "100%", height: "100%", style: { overflow: "visible", display: "block" }, children: /* @__PURE__ */ jsxRuntime.jsx(ChoreographyShell, { d, stroke, sw }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnHandles, { variant: "all" })
+  ] });
+}
+function SubChoreographyNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { width: "100%", height: "100%", position: "relative" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("svg", { width: "100%", height: "100%", style: { overflow: "visible", display: "block" }, children: /* @__PURE__ */ jsxRuntime.jsx(ChoreographyShell, { d, stroke, sw, collapsed: true }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnHandles, { variant: "all" })
+  ] });
+}
+function CallChoreographyNode({ data, selected }) {
+  const d = data;
+  const stroke = resolveStroke(selected, d.color?.stroke);
+  const sw = resolveStrokeWidth(selected);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { width: "100%", height: "100%", position: "relative" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("svg", { width: "100%", height: "100%", style: { overflow: "visible", display: "block" }, children: /* @__PURE__ */ jsxRuntime.jsx(ChoreographyShell, { d, stroke, sw, thick: true, collapsed: true }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(BpmnHandles, { variant: "all" })
+  ] });
+}
+
+// src/nodes/nodeTypes.ts
+var BPMN_NODE_TYPES = {
+  // Events
+  StartEvent: StartEventNode,
+  EndEvent: EndEventNode,
+  IntermediateCatchEvent: IntermediateCatchEventNode,
+  IntermediateThrowEvent: IntermediateThrowEventNode,
+  BoundaryEvent: BoundaryEventNode,
+  // Tasks — differentiated by data.elementType
+  Task: TaskNode,
+  UserTask: TaskNode,
+  ServiceTask: TaskNode,
+  ScriptTask: TaskNode,
+  ManualTask: TaskNode,
+  BusinessRuleTask: TaskNode,
+  ReceiveTask: TaskNode,
+  SendTask: TaskNode,
+  CallActivity: TaskNode,
+  // Gateways — differentiated by data.elementType
+  ExclusiveGateway: GatewayNode,
+  InclusiveGateway: GatewayNode,
+  ParallelGateway: GatewayNode,
+  EventBasedGateway: GatewayNode,
+  ComplexGateway: GatewayNode,
+  // Containers
+  SubProcess: SubProcessNode,
+  Pool: PoolNode,
+  Lane: LaneNode,
+  // Artifacts
+  Annotation: AnnotationNode,
+  Group: GroupNode,
+  // Data
+  DataObject: DataObjectNode,
+  DataObjectReference: DataObjectReferenceNode,
+  DataInput: DataInputNode,
+  DataOutput: DataOutputNode,
+  DataStore: DataStoreNode,
+  DataStoreReference: DataStoreReferenceNode,
+  // Conversation (§12)
+  Conversation: ConversationNode,
+  SubConversation: SubConversationNode,
+  CallConversation: CallConversationNode,
+  // Choreography (§11)
+  ChoreographyTask: ChoreographyTaskNode,
+  SubChoreography: SubChoreographyNode,
+  CallChoreography: CallChoreographyNode
+};
+
+// src/edges/path.ts
+function getEdgePoints(sourceX, sourceY, targetX, targetY, routingPoints) {
+  if (routingPoints && routingPoints.length >= 2) {
+    return routingPoints;
+  }
+  return [
+    { x: sourceX, y: sourceY },
+    { x: targetX, y: targetY }
+  ];
+}
+function getPolylineMidpoint(points) {
+  if (points.length === 0) return { x: 0, y: 0 };
+  if (points.length === 1) return points[0];
+  let total = 0;
+  const lengths = [];
+  for (let i = 1; i < points.length; i += 1) {
+    const dx = points[i].x - points[i - 1].x;
+    const dy = points[i].y - points[i - 1].y;
+    const length = Math.hypot(dx, dy);
+    lengths.push(length);
+    total += length;
+  }
+  const halfway = total / 2;
+  let traversed = 0;
+  for (let i = 1; i < points.length; i += 1) {
+    const length = lengths[i - 1];
+    if (traversed + length >= halfway) {
+      const ratio = length === 0 ? 0 : (halfway - traversed) / length;
+      return {
+        x: points[i - 1].x + (points[i].x - points[i - 1].x) * ratio,
+        y: points[i - 1].y + (points[i].y - points[i - 1].y) * ratio
+      };
+    }
+    traversed += length;
+  }
+  return points[points.length - 1];
+}
+function getSegmentAngle(points) {
+  if (points.length < 2) return 0;
+  const from = points[0];
+  const to = points[1];
+  return Math.atan2(to.y - from.y, to.x - from.x);
+}
+function getDefaultFlowMarkerPath(points) {
+  if (points.length < 2) return null;
+  const start = points[0];
+  const angle = getSegmentAngle(points);
+  const anchorX = start.x + Math.cos(angle) * 16;
+  const anchorY = start.y + Math.sin(angle) * 16;
+  const normalAngle = angle + Math.PI / 2;
+  const half = 7;
+  const x1 = anchorX + Math.cos(normalAngle) * half;
+  const y1 = anchorY + Math.sin(normalAngle) * half;
+  const x2 = anchorX - Math.cos(normalAngle) * half;
+  const y2 = anchorY - Math.sin(normalAngle) * half;
+  return `M ${x1} ${y1} L ${x2} ${y2}`;
+}
+function SequenceFlowEdge({
+  id,
+  sourceX,
+  sourceY,
+  targetX,
+  targetY,
+  sourcePosition,
+  targetPosition,
+  data,
+  label,
+  markerEnd,
+  style,
+  selected
+}) {
+  const d = data;
+  const points = d?.routingPoints;
+  const polyline = getEdgePoints(sourceX, sourceY, targetX, targetY, points);
+  const path = points && points.length >= 2 ? routing.pointsToSvgPath(points) : routing.getOrthogonalPath(sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition);
+  const midpoint = getPolylineMidpoint(polyline);
+  const defaultMarkerPath = d?.isDefault ? getDefaultFlowMarkerPath(polyline) : null;
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      react.BaseEdge,
+      {
+        id,
+        path,
+        ...d?.conditionExpression ? { markerStart: "url(#bpmn-diamond-open)" } : {},
+        markerEnd: markerEnd ?? "url(#bpmn-arrow)",
+        style: {
+          stroke: selected ? "#1a56db" : "#404040",
+          strokeWidth: selected ? 2 : 1.5,
+          ...style ?? {}
+        }
+      }
+    ),
+    defaultMarkerPath && /* @__PURE__ */ jsxRuntime.jsx(
+      "path",
+      {
+        d: defaultMarkerPath,
+        fill: "none",
+        stroke: selected ? "#1a56db" : "#404040",
+        strokeWidth: selected ? 2 : 1.5,
+        strokeLinecap: "round",
+        "data-testid": "bpmn-default-flow-marker"
+      }
+    ),
+    (label ?? d?.label) && /* @__PURE__ */ jsxRuntime.jsx(react.EdgeLabelRenderer, { children: /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        style: {
+          position: "absolute",
+          transform: `translate(-50%,-50%) translate(${midpoint.x}px,${midpoint.y}px)`,
+          fontSize: 11,
+          fontFamily: "Inter, system-ui, sans-serif",
+          background: "rgba(255,255,255,0.85)",
+          padding: "1px 4px",
+          borderRadius: 2,
+          pointerEvents: "all"
+        },
+        className: "nodrag nopan",
+        children: label ?? d?.label
+      }
+    ) })
+  ] });
+}
+function MessageFlowEdge({
+  id,
+  sourceX,
+  sourceY,
+  targetX,
+  targetY,
+  sourcePosition,
+  targetPosition,
+  data,
+  label,
+  markerEnd,
+  style,
+  selected
+}) {
+  const d = data;
+  const points = d?.routingPoints;
+  const polyline = getEdgePoints(sourceX, sourceY, targetX, targetY, points);
+  const path = points && points.length >= 2 ? routing.pointsToSvgPath(points) : routing.getOrthogonalPath(sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition);
+  const midpoint = getPolylineMidpoint(polyline);
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      react.BaseEdge,
+      {
+        id,
+        path,
+        markerStart: "url(#bpmn-circle-open)",
+        markerEnd: markerEnd ?? "url(#bpmn-arrow-open)",
+        style: {
+          stroke: selected ? "#1a56db" : "#404040",
+          strokeWidth: selected ? 2 : 1.5,
+          strokeDasharray: "6 3",
+          ...style ?? {}
+        }
+      }
+    ),
+    (label ?? d?.label) && /* @__PURE__ */ jsxRuntime.jsx(react.EdgeLabelRenderer, { children: /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        style: {
+          position: "absolute",
+          transform: `translate(-50%,-50%) translate(${midpoint.x}px,${midpoint.y}px)`,
+          fontSize: 11,
+          fontFamily: "Inter, system-ui, sans-serif",
+          background: "rgba(255,255,255,0.85)",
+          padding: "1px 4px",
+          borderRadius: 2,
+          pointerEvents: "all"
+        },
+        className: "nodrag nopan",
+        children: label ?? d?.label
+      }
+    ) })
+  ] });
+}
+function AssociationEdge({
+  id,
+  sourceX,
+  sourceY,
+  targetX,
+  targetY,
+  sourcePosition,
+  targetPosition,
+  data,
+  style,
+  selected
+}) {
+  const d = data;
+  const points = d?.routingPoints;
+  const direction = d?.associationDirection ?? "none";
+  const path = points && points.length >= 2 ? routing.pointsToSvgPath(points) : routing.getOrthogonalPath(sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    react.BaseEdge,
+    {
+      id,
+      path,
+      ...direction === "both" ? { markerStart: "url(#bpmn-arrow-open)" } : {},
+      ...direction === "one" || direction === "both" ? { markerEnd: "url(#bpmn-arrow-open)" } : {},
+      style: {
+        stroke: selected ? "#1a56db" : "#888",
+        strokeWidth: 1,
+        strokeDasharray: "3 3",
+        ...style ?? {}
+      }
+    }
+  );
+}
+function DataAssociationEdge({
+  id,
+  sourceX,
+  sourceY,
+  targetX,
+  targetY,
+  sourcePosition,
+  targetPosition,
+  data,
+  style,
+  selected
+}) {
+  const d = data;
+  const points = d?.routingPoints;
+  const path = points && points.length >= 2 ? routing.pointsToSvgPath(points) : routing.getOrthogonalPath(sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    react.BaseEdge,
+    {
+      id,
+      path,
+      markerEnd: "url(#bpmn-arrow-open)",
+      style: {
+        stroke: selected ? "#1a56db" : "#888",
+        strokeWidth: 1,
+        strokeDasharray: "3 3",
+        ...style ?? {}
+      }
+    }
+  );
+}
+function ConversationLinkEdge({
+  sourceX,
+  sourceY,
+  targetX,
+  targetY,
+  data,
+  markerEnd
+}) {
+  const d = data;
+  const stroke = BPMN_THEME.stroke;
+  const [path] = react.getStraightPath({ sourceX, sourceY, targetX, targetY });
+  return /* @__PURE__ */ jsxRuntime.jsxs("g", { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      react.BaseEdge,
+      {
+        path,
+        ...markerEnd ? { markerEnd } : {},
+        style: { stroke, strokeWidth: 5, fill: "none" }
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      react.BaseEdge,
+      {
+        path,
+        style: { stroke: "#ffffff", strokeWidth: 2, fill: "none" }
+      }
+    ),
+    d?.label && /* @__PURE__ */ jsxRuntime.jsx("text", { fontSize: BPMN_THEME.fontSize, fontFamily: BPMN_THEME.fontFamily, fill: stroke, children: /* @__PURE__ */ jsxRuntime.jsx("textPath", { href: `#${path}`, startOffset: "50%", textAnchor: "middle", children: d.label }) })
+  ] });
+}
+
+// src/edges/edgeTypes.ts
+var BPMN_EDGE_TYPES = {
+  sequenceFlow: SequenceFlowEdge,
+  messageFlow: MessageFlowEdge,
+  association: AssociationEdge,
+  dataAssociation: DataAssociationEdge,
+  conversationLink: ConversationLinkEdge
+};
+
+// src/xml/mapper.ts
+var MODDLE_TO_ELEMENT_TYPE = {
+  "bpmn:StartEvent": "StartEvent",
+  "bpmn:EndEvent": "EndEvent",
+  "bpmn:IntermediateCatchEvent": "IntermediateCatchEvent",
+  "bpmn:IntermediateThrowEvent": "IntermediateThrowEvent",
+  "bpmn:BoundaryEvent": "BoundaryEvent",
+  "bpmn:Task": "Task",
+  "bpmn:UserTask": "UserTask",
+  "bpmn:ServiceTask": "ServiceTask",
+  "bpmn:ScriptTask": "ScriptTask",
+  "bpmn:ManualTask": "ManualTask",
+  "bpmn:BusinessRuleTask": "BusinessRuleTask",
+  "bpmn:ReceiveTask": "ReceiveTask",
+  "bpmn:SendTask": "SendTask",
+  "bpmn:CallActivity": "CallActivity",
+  "bpmn:ExclusiveGateway": "ExclusiveGateway",
+  "bpmn:InclusiveGateway": "InclusiveGateway",
+  "bpmn:ParallelGateway": "ParallelGateway",
+  "bpmn:EventBasedGateway": "EventBasedGateway",
+  "bpmn:ComplexGateway": "ComplexGateway",
+  "bpmn:SubProcess": "SubProcess",
+  "bpmn:AdHocSubProcess": "SubProcess",
+  "bpmn:Transaction": "SubProcess",
+  "bpmn:TextAnnotation": "Annotation",
+  "bpmn:Group": "Group",
+  "bpmn:DataObject": "DataObject",
+  "bpmn:DataObjectReference": "DataObjectReference",
+  "bpmn:DataInput": "DataInput",
+  "bpmn:DataOutput": "DataOutput",
+  "bpmn:DataStore": "DataStore",
+  "bpmn:DataStoreReference": "DataStoreReference",
+  "bpmn:Conversation": "Conversation",
+  "bpmn:SubConversation": "SubConversation",
+  "bpmn:CallConversation": "CallConversation",
+  "bpmn:ChoreographyTask": "ChoreographyTask",
+  "bpmn:SubChoreography": "SubChoreography",
+  "bpmn:CallChoreography": "CallChoreography",
+  "bpmn:Lane": "Lane"
+};
+var ELEMENT_TYPE_TO_MODDLE = {
+  StartEvent: "bpmn:StartEvent",
+  EndEvent: "bpmn:EndEvent",
+  IntermediateCatchEvent: "bpmn:IntermediateCatchEvent",
+  IntermediateThrowEvent: "bpmn:IntermediateThrowEvent",
+  BoundaryEvent: "bpmn:BoundaryEvent",
+  Task: "bpmn:Task",
+  UserTask: "bpmn:UserTask",
+  ServiceTask: "bpmn:ServiceTask",
+  ScriptTask: "bpmn:ScriptTask",
+  ManualTask: "bpmn:ManualTask",
+  BusinessRuleTask: "bpmn:BusinessRuleTask",
+  ReceiveTask: "bpmn:ReceiveTask",
+  SendTask: "bpmn:SendTask",
+  CallActivity: "bpmn:CallActivity",
+  ExclusiveGateway: "bpmn:ExclusiveGateway",
+  InclusiveGateway: "bpmn:InclusiveGateway",
+  ParallelGateway: "bpmn:ParallelGateway",
+  EventBasedGateway: "bpmn:EventBasedGateway",
+  ComplexGateway: "bpmn:ComplexGateway",
+  SubProcess: "bpmn:SubProcess",
+  Pool: "bpmn:Participant",
+  Lane: "bpmn:Lane",
+  Annotation: "bpmn:TextAnnotation",
+  Group: "bpmn:Group",
+  DataObject: "bpmn:DataObject",
+  DataObjectReference: "bpmn:DataObjectReference",
+  DataInput: "bpmn:DataInput",
+  DataOutput: "bpmn:DataOutput",
+  DataStore: "bpmn:DataStore",
+  DataStoreReference: "bpmn:DataStoreReference",
+  Conversation: "bpmn:Conversation",
+  SubConversation: "bpmn:SubConversation",
+  CallConversation: "bpmn:CallConversation",
+  ChoreographyTask: "bpmn:ChoreographyTask",
+  SubChoreography: "bpmn:SubChoreography",
+  CallChoreography: "bpmn:CallChoreography"
+};
+var MODDLE_TO_EDGE_TYPE = {
+  "bpmn:SequenceFlow": "sequenceFlow",
+  "bpmn:MessageFlow": "messageFlow",
+  "bpmn:Association": "association",
+  "bpmn:DataInputAssociation": "dataAssociation",
+  "bpmn:DataOutputAssociation": "dataAssociation",
+  "bpmn:ConversationLink": "conversationLink"
+};
+var EDGE_TYPE_TO_MODDLE = {
+  sequenceFlow: "bpmn:SequenceFlow",
+  messageFlow: "bpmn:MessageFlow",
+  association: "bpmn:Association",
+  dataAssociation: "bpmn:DataInputAssociation",
+  conversationLink: "bpmn:ConversationLink"
+};
+var EVENT_DEF_TO_TRIGGER = {
+  "bpmn:MessageEventDefinition": "message",
+  "bpmn:TimerEventDefinition": "timer",
+  "bpmn:EscalationEventDefinition": "escalation",
+  "bpmn:ConditionalEventDefinition": "conditional",
+  "bpmn:ErrorEventDefinition": "error",
+  "bpmn:CancelEventDefinition": "cancel",
+  "bpmn:CompensateEventDefinition": "compensation",
+  "bpmn:SignalEventDefinition": "signal",
+  "bpmn:LinkEventDefinition": "link",
+  "bpmn:TerminateEventDefinition": "terminate"
+};
+var TRIGGER_TO_EVENT_DEF = {
+  message: "bpmn:MessageEventDefinition",
+  timer: "bpmn:TimerEventDefinition",
+  escalation: "bpmn:EscalationEventDefinition",
+  conditional: "bpmn:ConditionalEventDefinition",
+  error: "bpmn:ErrorEventDefinition",
+  cancel: "bpmn:CancelEventDefinition",
+  compensation: "bpmn:CompensateEventDefinition",
+  signal: "bpmn:SignalEventDefinition",
+  link: "bpmn:LinkEventDefinition",
+  terminate: "bpmn:TerminateEventDefinition"
+};
+
+// src/xml/importer.ts
+function asElements(v) {
+  return Array.isArray(v) ? v : [];
+}
+function asString(v) {
+  return typeof v === "string" && v.trim() ? v.trim() : void 0;
+}
+function extractDiagramInfo(definitions) {
+  const shapes = /* @__PURE__ */ new Map();
+  const waypoints = /* @__PURE__ */ new Map();
+  for (const diagram of asElements(definitions.diagrams)) {
+    const plane = diagram.plane;
+    if (!plane) continue;
+    for (const el of asElements(plane.planeElement)) {
+      const bpmnEl = el.bpmnElement;
+      if (!bpmnEl?.id) continue;
+      const id = bpmnEl.id;
+      if (el.$type === "bpmndi:BPMNShape") {
+        const b = el.bounds;
+        if (b) {
+          shapes.set(id, {
+            x: b.x,
+            y: b.y,
+            width: b.width,
+            height: b.height,
+            ...typeof el.isExpanded === "boolean" ? { isExpanded: el.isExpanded } : {}
+          });
+        }
+      } else if (el.$type === "bpmndi:BPMNEdge") {
+        const pts = el.waypoint ?? [];
+        if (pts.length) waypoints.set(id, pts);
+      }
+    }
+  }
+  return { shapes, waypoints };
+}
+function extractLaneMembership(process) {
+  const map = /* @__PURE__ */ new Map();
+  function walkLaneSet(laneSet2) {
+    for (const lane of asElements(laneSet2.lanes)) {
+      const laneId = lane.id;
+      if (!laneId) continue;
+      for (const ref of asElements(lane.flowNodeRef)) {
+        if (ref.id) map.set(ref.id, laneId);
+      }
+      const child = lane.childLaneSet;
+      if (child) walkLaneSet(child);
+    }
+  }
+  const laneSet = process.laneSet;
+  if (laneSet) walkLaneSet(laneSet);
+  return map;
+}
+function extractTrigger(el) {
+  const defs = asElements(el.eventDefinitions);
+  if (defs.length === 0) return void 0;
+  if (defs.length > 1) return el.$type.includes("Parallel") ? "parallelMultiple" : "multiple";
+  return EVENT_DEF_TO_TRIGGER[defs[0].$type];
+}
+function extractSubProcessVariant(el) {
+  if (el.$type === "bpmn:Transaction") return "transaction";
+  if (el.$type === "bpmn:AdHocSubProcess") return "adhoc";
+  if (el.triggeredByEvent === true) return "event";
+  return "embedded";
+}
+function walkFlowElements(elements, parentId, ctx, nodes, edges) {
+  for (const el of elements) {
+    const { $type, id } = el;
+    if (!id) continue;
+    const edgeType = MODDLE_TO_EDGE_TYPE[$type];
+    if (edgeType !== void 0) {
+      buildEdge(el, edgeType, ctx, edges);
+      continue;
+    }
+    if ($type === "bpmn:LaneSet") continue;
+    const elementType = MODDLE_TO_ELEMENT_TYPE[$type];
+    if (!elementType) {
+      ctx.warnings.push(`Unknown element type "${$type}" (id=${id}) \u2014 skipped.`);
+      continue;
+    }
+    buildNode(el, elementType, parentId, ctx, nodes);
+    if ($type === "bpmn:SubProcess" || $type === "bpmn:Transaction" || $type === "bpmn:AdHocSubProcess") {
+      const children = asElements(el.flowElements);
+      const laneMembership = extractLaneMembership(el);
+      walkFlowElements(children, id, { ...ctx, laneMembership }, nodes, edges);
+    }
+  }
+}
+function buildNode(el, elementType, parentId, ctx, nodes) {
+  const id = el.id;
+  const meta = BPMN_ELEMENT_CATALOG[elementType];
+  const shape = ctx.shapes.get(id);
+  const x = shape?.x ?? ctx.autoX.value;
+  const y = shape?.y ?? 100;
+  if (!shape) ctx.autoX.value += (meta?.defaultWidth ?? 120) + 20;
+  const label = asString(el.name);
+  const trigger = extractTrigger(el);
+  const isNonInterrupting = el.cancelActivity === false;
+  const data = {
+    elementType,
+    ...label ? { label } : {},
+    ...trigger ? { trigger } : {},
+    ...isNonInterrupting ? { isNonInterrupting: true } : {}
+  };
+  if (elementType === "SubProcess") {
+    const variant = extractSubProcessVariant(el);
+    if (variant) data.subProcessVariant = variant;
+    const isExpanded = shape?.isExpanded ?? true;
+    data.isExpanded = isExpanded;
+  }
+  const laneId = ctx.laneMembership.get(id);
+  const effectiveParentId = laneId ?? parentId;
+  const node = {
+    id,
+    type: elementType,
+    position: { x, y },
+    data,
+    width: shape?.width ?? meta?.defaultWidth,
+    height: shape?.height ?? meta?.defaultHeight,
+    ...effectiveParentId ? { parentId: effectiveParentId } : {}
+  };
+  nodes.push(node);
+}
+function buildEdge(el, edgeType, ctx, edges) {
+  const id = el.id;
+  const source = el.sourceRef?.id;
+  const target = el.targetRef?.id;
+  if (!source || !target) {
+    ctx.warnings.push(`Edge "${id}" missing source or target \u2014 skipped.`);
+    return;
+  }
+  const label = asString(el.name);
+  const condExpr = el.conditionExpression;
+  const data = {
+    edgeType,
+    ...label ? { label } : {},
+    ...condExpr?.body ? { conditionExpression: condExpr.body } : {}
+  };
+  const waypoints = ctx.waypoints.get(id);
+  if (waypoints?.length) data.routingPoints = waypoints;
+  edges.push({ id, type: edgeType, source, target, data });
+}
+function handleCollaboration(collaboration, ctx, nodes, edges) {
+  for (const participant of asElements(collaboration.participants)) {
+    const id = participant.id;
+    if (!id) continue;
+    const label = asString(participant.name);
+    const shape = ctx.shapes.get(id);
+    const poolNode = {
+      id,
+      type: "Pool",
+      position: { x: shape?.x ?? 0, y: shape?.y ?? 0 },
+      data: { elementType: "Pool", ...label ? { label } : {} },
+      width: shape?.width ?? 600,
+      height: shape?.height ?? 200
+    };
+    nodes.push(poolNode);
+    const processRef = participant.processRef;
+    if (processRef) {
+      const laneMembership = extractLaneMembership(processRef);
+      walkFlowElements(
+        asElements(processRef.flowElements),
+        id,
+        { ...ctx, laneMembership },
+        nodes,
+        edges
+      );
+      const laneSet = processRef.laneSet;
+      if (laneSet) {
+        addLaneNodes(laneSet, id, ctx, nodes);
+      }
+    }
+  }
+  for (const mf of asElements(collaboration.messageFlows)) {
+    buildEdge(mf, "messageFlow", ctx, edges);
+  }
+  for (const cl of asElements(collaboration.conversationLinks)) {
+    buildEdge(cl, "conversationLink", ctx, edges);
+  }
+}
+function addLaneNodes(laneSet, poolId, ctx, nodes) {
+  for (const lane of asElements(laneSet.lanes)) {
+    const id = lane.id;
+    if (!id) continue;
+    const label = asString(lane.name);
+    const shape = ctx.shapes.get(id);
+    nodes.push({
+      id,
+      type: "Lane",
+      position: { x: shape?.x ?? 30, y: shape?.y ?? 0 },
+      data: { elementType: "Lane", ...label ? { label } : {} },
+      width: shape?.width ?? 570,
+      height: shape?.height ?? 120,
+      parentId: poolId
+    });
+    const child = lane.childLaneSet;
+    if (child) addLaneNodes(child, poolId, ctx, nodes);
+  }
+}
+async function parseBpmnXml(xml) {
+  const moddle = new bpmnModdle.BpmnModdle();
+  const warnings = [];
+  let rootElement;
+  try {
+    const result = await moddle.fromXML(xml);
+    rootElement = result.rootElement;
+    for (const w of result.warnings) warnings.push(w.message);
+  } catch (err) {
+    throw new Error(`Failed to parse BPMN XML: ${String(err)}`);
+  }
+  const nodes = [];
+  const edges = [];
+  const { shapes, waypoints } = extractDiagramInfo(rootElement);
+  const ctx = {
+    shapes,
+    waypoints,
+    laneMembership: /* @__PURE__ */ new Map(),
+    warnings,
+    autoX: { value: 50 }
+  };
+  for (const rootEl of asElements(rootElement.rootElements)) {
+    if (rootEl.$type === "bpmn:Collaboration") {
+      handleCollaboration(rootEl, ctx, nodes, edges);
+    } else if (rootEl.$type === "bpmn:Process") {
+      const laneMembership = extractLaneMembership(rootEl);
+      const laneSet = rootEl.laneSet;
+      if (laneSet) addLaneNodes(laneSet, "", ctx, nodes);
+      walkFlowElements(
+        asElements(rootEl.flowElements),
+        void 0,
+        { ...ctx, laneMembership },
+        nodes,
+        edges
+      );
+    }
+  }
+  return { nodes, edges, warnings };
+}
+function uid(prefix, id) {
+  return `${prefix}_${id}`;
+}
+function asNodes(nodes, types) {
+  return nodes.filter((n) => types.includes(n.data.elementType));
+}
+function buildFlowableAttrs(data) {
+  const attrs = {};
+  if (data.flowableAssignee) attrs["flowable:assignee"] = data.flowableAssignee;
+  if (data.flowableCandidateGroups) attrs["flowable:candidateGroups"] = data.flowableCandidateGroups;
+  if (data.flowableCandidateUsers) attrs["flowable:candidateUsers"] = data.flowableCandidateUsers;
+  if (data.flowableFormKey) attrs["flowable:formKey"] = data.flowableFormKey;
+  if (data.flowableDueDate) attrs["flowable:dueDate"] = data.flowableDueDate;
+  if (data.flowableType) attrs["flowable:type"] = data.flowableType;
+  if (data.flowableExpression) attrs["flowable:expression"] = data.flowableExpression;
+  if (data.flowableClass) attrs["flowable:class"] = data.flowableClass;
+  if (data.flowableDelegateExpression) attrs["flowable:delegateExpression"] = data.flowableDelegateExpression;
+  return attrs;
+}
+function buildSemanticModel(moddle, nodes, edges, opts) {
+  const defId = opts.id ?? "Definitions_1";
+  const defName = opts.name;
+  const poolNodes = asNodes(nodes, ["Pool"]);
+  const laneNodes = asNodes(nodes, ["Lane"]);
+  const isCollaboration = poolNodes.length > 0;
+  const definitions = moddle.create("bpmn:Definitions", {
+    id: defId,
+    targetNamespace: "http://bpmn.io/schema/bpmn",
+    ...defName ? { name: defName } : {}
+  });
+  const rootElements = [];
+  if (isCollaboration) {
+    const participants = [];
+    const processes = [];
+    for (const pool of poolNodes) {
+      const processId = `Process_${pool.id}`;
+      const process = buildProcess(moddle, nodes, edges, pool.id, laneNodes, processId);
+      processes.push(process);
+      const participant = moddle.create("bpmn:Participant", {
+        id: pool.id,
+        name: pool.data.label ?? "",
+        processRef: process
+      });
+      participants.push(participant);
+    }
+    const messageFlowEdges = edges.filter((e) => e.data?.edgeType === "messageFlow");
+    const conversationLinkEdges = edges.filter((e) => e.data?.edgeType === "conversationLink");
+    const messageFlows = messageFlowEdges.map(
+      (e) => moddle.create("bpmn:MessageFlow", {
+        id: e.id,
+        name: e.data?.label ?? "",
+        sourceRef: { id: e.source },
+        targetRef: { id: e.target }
+      })
+    );
+    const conversationLinks = conversationLinkEdges.map(
+      (e) => moddle.create("bpmn:ConversationLink", {
+        id: e.id,
+        sourceRef: { id: e.source },
+        targetRef: { id: e.target }
+      })
+    );
+    const collaboration = moddle.create("bpmn:Collaboration", {
+      id: `Collaboration_${defId}`,
+      participants,
+      messageFlows,
+      conversationLinks
+    });
+    rootElements.push(collaboration, ...processes);
+  } else {
+    const process = buildProcess(moddle, nodes, edges, void 0, laneNodes, "Process_1");
+    rootElements.push(process);
+  }
+  definitions.rootElements = rootElements;
+  return definitions;
+}
+function buildProcess(moddle, allNodes, allEdges, poolId, laneNodes, processId) {
+  const myNodes = poolId ? allNodes.filter(
+    (n) => n.parentId === poolId || laneNodes.some((l) => l.id === n.parentId && l.parentId === poolId)
+  ) : allNodes.filter((n) => n.data.elementType !== "Pool" && n.data.elementType !== "Lane");
+  const myLanes = laneNodes.filter((l) => poolId ? l.parentId === poolId : true);
+  const flowElements = [];
+  for (const node of myNodes) {
+    const el = buildFlowElement(moddle, node);
+    if (el) flowElements.push(el);
+  }
+  const myNodeIds = new Set(myNodes.map((n) => n.id));
+  const myEdges = allEdges.filter(
+    (e) => (e.data?.edgeType === "sequenceFlow" || e.data?.edgeType === "association" || e.data?.edgeType === "dataAssociation") && myNodeIds.has(e.source) && myNodeIds.has(e.target)
+  );
+  for (const edge of myEdges) {
+    const edgeMeta = buildEdgeElement(moddle, edge);
+    if (edgeMeta) flowElements.push(edgeMeta);
+  }
+  const process = moddle.create("bpmn:Process", {
+    id: processId,
+    isExecutable: true,
+    flowElements
+  });
+  if (myLanes.length > 0) {
+    const laneElements = myLanes.map(
+      (l) => moddle.create("bpmn:Lane", {
+        id: l.id,
+        name: l.data.label ?? "",
+        flowNodeRef: myNodes.filter((n) => n.parentId === l.id).map((n) => ({ id: n.id }))
+      })
+    );
+    process.laneSet = moddle.create("bpmn:LaneSet", {
+      id: `LaneSet_${processId}`,
+      lanes: laneElements
+    });
+  }
+  return process;
+}
+function buildFlowElement(moddle, node, _allNodes, _allEdges) {
+  const { elementType, label, trigger } = node.data;
+  if (elementType === "Pool" || elementType === "Lane") return null;
+  const moddleType = ELEMENT_TYPE_TO_MODDLE[elementType];
+  if (!moddleType) return null;
+  const attrs = {
+    id: node.id,
+    name: label ?? ""
+  };
+  if (trigger && trigger !== "none") {
+    const defType = TRIGGER_TO_EVENT_DEF[trigger];
+    if (defType) {
+      attrs.eventDefinitions = [moddle.create(defType, { id: uid("EventDef", node.id) })];
+    }
+  }
+  if (elementType === "SubProcess" && node.data.subProcessVariant === "transaction") {
+    return moddle.create("bpmn:Transaction", attrs);
+  }
+  if (elementType === "SubProcess" && node.data.subProcessVariant === "adhoc") {
+    return moddle.create("bpmn:AdHocSubProcess", attrs);
+  }
+  const element = moddle.create(moddleType, attrs);
+  const flowableAttrs = buildFlowableAttrs(node.data);
+  if (Object.keys(flowableAttrs).length > 0) {
+    element.$attrs = flowableAttrs;
+  }
+  return element;
+}
+function buildEdgeElement(moddle, edge) {
+  if (!edge.data) return null;
+  const moddleType = EDGE_TYPE_TO_MODDLE[edge.data.edgeType];
+  if (!moddleType) return null;
+  const attrs = {
+    id: edge.id,
+    name: edge.data.label ?? "",
+    sourceRef: { id: edge.source },
+    targetRef: { id: edge.target }
+  };
+  if (edge.data.conditionExpression) {
+    attrs.conditionExpression = moddle.create("bpmn:FormalExpression", {
+      body: edge.data.conditionExpression
+    });
+  }
+  return moddle.create(moddleType, attrs);
+}
+function buildBpmnDI(moddle, definitions, nodes, edges) {
+  const shapes = [];
+  const edgeShapes = [];
+  for (const node of nodes) {
+    const meta = BPMN_ELEMENT_CATALOG[node.data.elementType];
+    const w = node.width ?? meta?.defaultWidth ?? 120;
+    const h = node.height ?? meta?.defaultHeight ?? 60;
+    const bounds = moddle.create("dc:Bounds", {
+      x: node.position.x,
+      y: node.position.y,
+      width: w,
+      height: h
+    });
+    const shape = moddle.create("bpmndi:BPMNShape", {
+      id: uid("BPMNShape", node.id),
+      bpmnElement: { id: node.id },
+      bounds
+    });
+    if (node.data.isExpanded !== void 0) {
+      shape.isExpanded = node.data.isExpanded;
+    }
+    shapes.push(shape);
+  }
+  for (const edge of edges) {
+    const waypoints = edge.data?.routingPoints?.map(
+      (p) => moddle.create("dc:Point", { x: p.x, y: p.y })
+    ) ?? [];
+    edgeShapes.push(
+      moddle.create("bpmndi:BPMNEdge", {
+        id: uid("BPMNEdge", edge.id),
+        bpmnElement: { id: edge.id },
+        waypoint: waypoints
+      })
+    );
+  }
+  const rootEls = definitions.rootElements;
+  const planeElement = rootEls?.[0];
+  const plane = moddle.create("bpmndi:BPMNPlane", {
+    id: "BPMNPlane_1",
+    bpmnElement: planeElement ?? { id: "unknown" },
+    planeElement: [...shapes, ...edgeShapes]
+  });
+  const diagram = moddle.create("bpmndi:BPMNDiagram", {
+    id: "BPMNDiagram_1",
+    plane
+  });
+  definitions.diagrams = [diagram];
+}
+async function serializeBpmnXml(nodes, edges, opts = {}) {
+  const moddle = new bpmnModdle.BpmnModdle();
+  const definitions = buildSemanticModel(moddle, nodes, edges, opts);
+  buildBpmnDI(moddle, definitions, nodes, edges);
+  const { xml } = await moddle.toXML(definitions, {
+    format: opts.format ?? true
+  });
+  return xml;
+}
+
+// src/simulation/evaluator.ts
+function parseValue(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw.startsWith("'") && raw.endsWith("'") || raw.startsWith('"') && raw.endsWith('"'))
+    return raw.slice(1, -1);
+  const n = Number(raw);
+  return isNaN(n) ? raw : n;
+}
+function evalCondition(expr, variables) {
+  const body = expr.trim().replace(/^\$\{|\}$/g, "").trim();
+  if (!body) return false;
+  if (body.startsWith("!")) {
+    const inner = body.slice(1).trim();
+    return !Boolean(variables[inner]);
+  }
+  const neq = body.match(/^(\w+)\s*!=\s*(.+)$/);
+  if (neq) return String(variables[neq[1].trim()]) !== String(parseValue(neq[2].trim()));
+  const eq = body.match(/^(\w+)\s*==\s*(.+)$/);
+  if (eq) {
+    const lhs = variables[eq[1].trim()];
+    const rhs = parseValue(eq[2].trim());
+    return lhs == rhs;
+  }
+  const gte = body.match(/^(\w+)\s*>=\s*(-?\d+\.?\d*)$/);
+  if (gte) return Number(variables[gte[1].trim()]) >= Number(gte[2]);
+  const lte = body.match(/^(\w+)\s*<=\s*(-?\d+\.?\d*)$/);
+  if (lte) return Number(variables[lte[1].trim()]) <= Number(lte[2]);
+  const gt = body.match(/^(\w+)\s*>\s*(-?\d+\.?\d*)$/);
+  if (gt) return Number(variables[gt[1].trim()]) > Number(gt[2]);
+  const lt = body.match(/^(\w+)\s*<\s*(-?\d+\.?\d*)$/);
+  if (lt) return Number(variables[lt[1].trim()]) < Number(lt[2]);
+  return Boolean(variables[body]);
+}
+
+// src/simulation/index.ts
+function seqOut(diagram, nodeId) {
+  return diagram.edges.filter((e) => e.type === "sequenceFlow" && e.source === nodeId);
+}
+function seqIn(diagram, nodeId) {
+  return diagram.edges.filter((e) => e.type === "sequenceFlow" && e.target === nodeId);
+}
+function nodeById(diagram, id) {
+  return diagram.nodes.find((n) => n.id === id);
+}
+function boundaryEventsOf(diagram, hostId) {
+  return diagram.nodes.filter((n) => n.type === "BoundaryEvent" && n.attachedToRef === hostId);
+}
+var _tokenCounter = 0;
+function nextTokenId() {
+  return `tok_${++_tokenCounter}`;
+}
+var GATEWAY_TYPES2 = /* @__PURE__ */ new Set([
+  "ExclusiveGateway",
+  "InclusiveGateway",
+  "ParallelGateway",
+  "ComplexGateway",
+  "EventBasedGateway"
+]);
+var TASK_TYPES2 = /* @__PURE__ */ new Set([
+  "Task",
+  "UserTask",
+  "ServiceTask",
+  "ScriptTask",
+  "ManualTask",
+  "BusinessRuleTask",
+  "ReceiveTask",
+  "SendTask",
+  "CallActivity"
+]);
+function isAutomatic(nodeType) {
+  return nodeType === "StartEvent" || nodeType === "EndEvent" || nodeType === "IntermediateThrowEvent" || GATEWAY_TYPES2.has(nodeType);
+}
+function isManual(nodeType) {
+  return TASK_TYPES2.has(nodeType) || nodeType === "IntermediateCatchEvent" || nodeType === "BoundaryEvent";
+}
+function isSubProcess(nodeType) {
+  return nodeType === "SubProcess" || nodeType === "Transaction" || nodeType === "AdHocSubProcess";
+}
+function getScopeId(diagram, nodeId) {
+  const node = nodeById(diagram, nodeId);
+  if (!node?.parentId) return "root";
+  const parent = nodeById(diagram, node.parentId);
+  return parent && isSubProcess(parent.type) ? node.parentId : "root";
+}
+function withLog(state, entry) {
+  return { ...state, log: [...state.log, { ...entry, step: state.step }] };
+}
+function disperseToTargets(diagram, state, sourceId, consumedTokenId) {
+  const outEdges = seqOut(diagram, sourceId);
+  if (outEdges.length === 0) return state;
+  let next = {
+    ...state,
+    tokens: consumedTokenId !== null ? state.tokens.filter((t) => t.id !== consumedTokenId) : state.tokens
+  };
+  for (const edge of outEdges) {
+    const target = nodeById(diagram, edge.target);
+    if (!target) continue;
+    const newToken = {
+      id: nextTokenId(),
+      elementId: edge.target,
+      scopeId: getScopeId(diagram, edge.target)
+    };
+    next = {
+      ...next,
+      tokens: [...next.tokens, newToken]
+    };
+    next = withLog(next, {
+      type: "created",
+      elementId: edge.target,
+      tokenId: newToken.id,
+      message: `Token created at "${target.name ?? edge.target}".`
+    });
+  }
+  return next;
+}
+function enterSubProcess(diagram, state, subProcNode) {
+  const childStarts = diagram.nodes.filter(
+    (n) => n.type === "StartEvent" && n.parentId === subProcNode.id
+  );
+  let next = {
+    ...state,
+    enteredScopes: [...state.enteredScopes, subProcNode.id]
+  };
+  for (const startNode of childStarts) {
+    const newToken = {
+      id: nextTokenId(),
+      elementId: startNode.id,
+      scopeId: subProcNode.id
+    };
+    next = {
+      ...next,
+      tokens: [...next.tokens, newToken]
+    };
+    next = withLog(next, {
+      type: "created",
+      elementId: startNode.id,
+      tokenId: newToken.id,
+      message: `SubProcess "${subProcNode.name ?? subProcNode.id}" entered \u2014 token at "${startNode.name ?? startNode.id}".`
+    });
+  }
+  return next;
+}
+function fireAutomatic(diagram, state, token) {
+  const node = nodeById(diagram, token.elementId);
+  if (!node) return state;
+  const { type } = node;
+  const vars = state.variables;
+  if (type === "EndEvent") {
+    let next = {
+      ...state,
+      tokens: state.tokens.filter((t) => t.id !== token.id)
+    };
+    next = withLog(next, {
+      type: "consumed",
+      elementId: node.id,
+      tokenId: token.id,
+      message: `Token consumed at end event "${node.name ?? node.id}".`
+    });
+    return next;
+  }
+  if (type === "StartEvent" || type === "IntermediateThrowEvent") {
+    let next = withLog(state, {
+      type: "fired",
+      elementId: node.id,
+      tokenId: token.id,
+      message: `"${node.name ?? node.id}" (${type}) fired.`
+    });
+    return disperseToTargets(diagram, next, node.id, token.id);
+  }
+  if (type === "ExclusiveGateway") {
+    const incoming = seqIn(diagram, node.id);
+    if (incoming.length >= 2) {
+      let next2 = withLog(state, {
+        type: "joined",
+        elementId: node.id,
+        tokenId: token.id,
+        message: `ExclusiveGateway "${node.name ?? node.id}" join \u2014 token passes through.`
+      });
+      return disperseToTargets(diagram, next2, node.id, token.id);
+    }
+    const outEdges = seqOut(diagram, node.id);
+    const chosen = outEdges.find(
+      (e) => e.conditionExpression && !e.isDefault && evalCondition(e.conditionExpression, vars)
+    ) ?? outEdges.find((e) => e.isDefault) ?? outEdges[0];
+    if (!chosen) return state;
+    const target = nodeById(diagram, chosen.target);
+    if (!target) return state;
+    const newToken = {
+      id: nextTokenId(),
+      elementId: chosen.target,
+      scopeId: getScopeId(diagram, chosen.target)
+    };
+    let next = {
+      ...state,
+      tokens: [...state.tokens.filter((t) => t.id !== token.id), newToken]
+    };
+    next = withLog(next, {
+      type: "fired",
+      elementId: node.id,
+      tokenId: token.id,
+      message: `ExclusiveGateway "${node.name ?? node.id}" split \u2192 "${target.name ?? chosen.target}".`
+    });
+    return next;
+  }
+  if (type === "InclusiveGateway") {
+    const incoming = seqIn(diagram, node.id);
+    if (incoming.length >= 2) {
+      let next2 = withLog(state, {
+        type: "joined",
+        elementId: node.id,
+        tokenId: token.id,
+        message: `InclusiveGateway "${node.name ?? node.id}" join.`
+      });
+      return disperseToTargets(diagram, next2, node.id, token.id);
+    }
+    const outEdges = seqOut(diagram, node.id);
+    const matching = outEdges.filter(
+      (e) => e.conditionExpression && !e.isDefault && evalCondition(e.conditionExpression, vars)
+    );
+    const activePaths = matching.length > 0 ? matching : outEdges.filter((e) => e.isDefault);
+    const paths = activePaths.length > 0 ? activePaths : outEdges;
+    let next = withLog(state, {
+      type: "split",
+      elementId: node.id,
+      tokenId: token.id,
+      message: `InclusiveGateway "${node.name ?? node.id}" split \u2192 ${paths.length} path(s).`
+    });
+    next = { ...next, tokens: next.tokens.filter((t) => t.id !== token.id) };
+    for (const edge of paths) {
+      const tgt = nodeById(diagram, edge.target);
+      if (!tgt) continue;
+      const newToken = {
+        id: nextTokenId(),
+        elementId: edge.target,
+        scopeId: getScopeId(diagram, edge.target)
+      };
+      next = { ...next, tokens: [...next.tokens, newToken] };
+      next = withLog(next, {
+        type: "created",
+        elementId: edge.target,
+        tokenId: newToken.id,
+        message: `Token created at "${tgt.name ?? edge.target}".`
+      });
+    }
+    return next;
+  }
+  if (type === "ParallelGateway") {
+    const incoming = seqIn(diagram, node.id);
+    if (incoming.length >= 2) {
+      const atGateway = state.tokens.filter((t) => t.elementId === node.id);
+      if (atGateway.length < incoming.length) {
+        return withLog(state, {
+          type: "blocked",
+          elementId: node.id,
+          tokenId: token.id,
+          message: `ParallelGateway "${node.name ?? node.id}" waiting for ${incoming.length - atGateway.length} more token(s).`
+        });
+      }
+      const consumeIds = new Set(atGateway.map((t) => t.id));
+      let next2 = {
+        ...state,
+        tokens: state.tokens.filter((t) => !consumeIds.has(t.id))
+      };
+      next2 = withLog(next2, {
+        type: "joined",
+        elementId: node.id,
+        message: `ParallelGateway "${node.name ?? node.id}" join fired \u2014 all paths synchronized.`
+      });
+      return disperseToTargets(diagram, next2, node.id, null);
+    }
+    let next = withLog(state, {
+      type: "split",
+      elementId: node.id,
+      tokenId: token.id,
+      message: `ParallelGateway "${node.name ?? node.id}" split \u2192 ${seqOut(diagram, node.id).length} paths.`
+    });
+    return disperseToTargets(diagram, next, node.id, token.id);
+  }
+  if (type === "EventBasedGateway") {
+    let next = withLog(state, {
+      type: "split",
+      elementId: node.id,
+      tokenId: token.id,
+      message: `EventBasedGateway "${node.name ?? node.id}" waiting \u2014 ${seqOut(diagram, node.id).length} competing event(s).`
+    });
+    return disperseToTargets(diagram, next, node.id, token.id);
+  }
+  if (type === "ComplexGateway") {
+    const outEdges = seqOut(diagram, node.id);
+    const chosen = outEdges[0];
+    if (!chosen) return state;
+    const newToken = {
+      id: nextTokenId(),
+      elementId: chosen.target,
+      scopeId: getScopeId(diagram, chosen.target)
+    };
+    let next = {
+      ...state,
+      tokens: [...state.tokens.filter((t) => t.id !== token.id), newToken]
+    };
+    next = withLog(next, {
+      type: "fired",
+      elementId: node.id,
+      tokenId: token.id,
+      message: `ComplexGateway "${node.name ?? node.id}" fired \u2192 "${chosen.target}".`
+    });
+    return next;
+  }
+  return state;
+}
+function createSimulation(diagram, initialVariables = {}) {
+  _tokenCounter = 0;
+  const startEvents = diagram.nodes.filter(
+    (n) => n.type === "StartEvent" && !n.parentId
+  );
+  const tokens = startEvents.map((n) => ({
+    id: nextTokenId(),
+    elementId: n.id,
+    scopeId: "root"
+  }));
+  const log = startEvents.map((n, i) => ({
+    step: 0,
+    type: "created",
+    elementId: n.id,
+    tokenId: tokens[i]?.id,
+    message: `Simulation started \u2014 token placed at "${n.name ?? n.id}".`
+  }));
+  return {
+    tokens,
+    step: 0,
+    status: startEvents.length > 0 ? "running" : "idle",
+    log,
+    variables: initialVariables,
+    enteredScopes: []
+  };
+}
+function tick(diagram, state) {
+  if (state.status !== "running") return state;
+  let current = { ...state, step: state.step + 1 };
+  let changed = true;
+  let guard = 0;
+  while (changed && guard < 1e3) {
+    guard++;
+    changed = false;
+    for (const token of current.tokens) {
+      const node = nodeById(diagram, token.elementId);
+      if (!node) continue;
+      if (isSubProcess(node.type)) {
+        if (!current.enteredScopes.includes(node.id)) {
+          const childStarts = diagram.nodes.filter(
+            (n) => n.type === "StartEvent" && n.parentId === node.id
+          );
+          if (childStarts.length > 0) {
+            current = enterSubProcess(diagram, current, node);
+            changed = true;
+            break;
+          }
+        } else {
+          const scopeTokens = current.tokens.filter((t) => t.scopeId === node.id);
+          if (scopeTokens.length === 0) {
+            let next = withLog(current, {
+              type: "fired",
+              elementId: node.id,
+              tokenId: token.id,
+              message: `SubProcess "${node.name ?? node.id}" completed.`
+            });
+            current = disperseToTargets(diagram, next, node.id, token.id);
+            changed = true;
+            break;
+          }
+        }
+        continue;
+      }
+      if (node.type === "ParallelGateway") {
+        const incoming = seqIn(diagram, node.id);
+        const atGateway = current.tokens.filter((t) => t.elementId === node.id);
+        if (incoming.length >= 2 && atGateway.length < incoming.length) continue;
+      }
+      if (!isAutomatic(node.type)) continue;
+      const prevLen = current.tokens.length;
+      const prevIds = new Set(current.tokens.map((t) => t.id));
+      current = fireAutomatic(diagram, current, token);
+      const same = current.tokens.length === prevLen && [...prevIds].every((id) => current.tokens.some((t) => t.id === id));
+      if (!same) {
+        changed = true;
+        break;
+      }
+    }
+  }
+  if (current.tokens.length === 0) {
+    current = { ...current, status: "completed" };
+  }
+  return current;
+}
+function fire(diagram, state, elementId, variables) {
+  if (state.status !== "running") return state;
+  const node = nodeById(diagram, elementId);
+  if (!node) return state;
+  const mergedVars = variables ? { ...state.variables, ...variables } : state.variables;
+  if (node.type === "BoundaryEvent") {
+    const hostId = node.attachedToRef;
+    if (!hostId) return state;
+    const hostToken = state.tokens.find((t) => t.elementId === hostId);
+    if (!hostToken) return state;
+    const isInterrupting = node.isInterrupting !== false;
+    let next2 = { ...state, variables: mergedVars, step: state.step + 1 };
+    next2 = withLog(next2, {
+      type: isInterrupting ? "interrupted" : "fired",
+      elementId,
+      tokenId: hostToken.id,
+      message: `BoundaryEvent "${node.name ?? elementId}" fired (${isInterrupting ? "interrupting" : "non-interrupting"}).`
+    });
+    if (isInterrupting) {
+      next2 = { ...next2, tokens: next2.tokens.filter((t) => t.id !== hostToken.id) };
+    }
+    next2 = disperseToTargets(diagram, next2, elementId, null);
+    return tick(diagram, { ...next2, step: next2.step - 1 });
+  }
+  const token = state.tokens.find((t) => t.elementId === elementId);
+  if (!token) return state;
+  if (node.type === "IntermediateCatchEvent") {
+    const gwEdge = seqIn(diagram, elementId).find((e) => {
+      const src = nodeById(diagram, e.source);
+      return src?.type === "EventBasedGateway";
+    });
+    if (gwEdge) {
+      const gw = nodeById(diagram, gwEdge.source);
+      if (gw) {
+        const siblingTargets = new Set(
+          seqOut(diagram, gw.id).map((e) => e.target).filter((id) => id !== elementId)
+        );
+        state = {
+          ...state,
+          tokens: state.tokens.filter((t) => !siblingTargets.has(t.elementId))
+        };
+      }
+    }
+  }
+  let next = { ...state, variables: mergedVars, step: state.step + 1 };
+  next = withLog(next, {
+    type: "fired",
+    elementId,
+    tokenId: token.id,
+    message: `"${node.name ?? elementId}" (${node.type}) manually fired.`
+  });
+  next = disperseToTargets(diagram, next, elementId, token.id);
+  return tick(diagram, { ...next, step: next.step - 1 });
+}
+function getFireable(diagram, state) {
+  if (state.status !== "running") return [];
+  const fireable = /* @__PURE__ */ new Set();
+  for (const token of state.tokens) {
+    const node = nodeById(diagram, token.elementId);
+    if (!node) continue;
+    if (isManual(node.type)) {
+      fireable.add(node.id);
+    }
+    if (TASK_TYPES2.has(node.type)) {
+      for (const be of boundaryEventsOf(diagram, node.id)) {
+        fireable.add(be.id);
+      }
+    }
+  }
+  return [...fireable];
+}
+function isCompleted(state) {
+  return state.status === "completed";
+}
+function setVariable(state, key, value) {
+  return { ...state, variables: { ...state.variables, [key]: value } };
+}
+
+// src/flowable/adapter.ts
+var PreviewAdapter = class {
+  constructor(diagram, initialVariables = {}) {
+    this.diagram = diagram;
+    this.mode = "preview";
+    this.state = createSimulation(diagram, initialVariables);
+  }
+  async start(variables) {
+    this.state = tick(this.diagram, createSimulation(this.diagram, variables ?? {}));
+    return this.state;
+  }
+  async tick() {
+    this.state = tick(this.diagram, this.state);
+    return this.state;
+  }
+  async fire(elementId, variables) {
+    this.state = fire(this.diagram, this.state, elementId, variables);
+    return this.state;
+  }
+  async getFireable() {
+    return getFireable(this.diagram, this.state);
+  }
+  getState() {
+    return this.state;
+  }
+  isCompleted() {
+    return isCompleted(this.state);
+  }
+};
+function createPreviewAdapter(diagram, initialVariables) {
+  return new PreviewAdapter(diagram, initialVariables);
+}
+
+exports.AnnotationNode = AnnotationNode;
+exports.AssociationEdge = AssociationEdge;
+exports.BPMN_EDGE_TYPES = BPMN_EDGE_TYPES;
+exports.BPMN_ELEMENT_CATALOG = BPMN_ELEMENT_CATALOG;
+exports.BPMN_NODE_TYPES = BPMN_NODE_TYPES;
+exports.BoundaryEventNode = BoundaryEventNode;
+exports.CallChoreographyNode = CallChoreographyNode;
+exports.CallConversationNode = CallConversationNode;
+exports.ChoreographyTaskNode = ChoreographyTaskNode;
+exports.ConversationLinkEdge = ConversationLinkEdge;
+exports.ConversationNode = ConversationNode;
+exports.DataAssociationEdge = DataAssociationEdge;
+exports.DataInputNode = DataInputNode;
+exports.DataObjectNode = DataObjectNode;
+exports.DataObjectReferenceNode = DataObjectReferenceNode;
+exports.DataOutputNode = DataOutputNode;
+exports.DataStoreNode = DataStoreNode;
+exports.DataStoreReferenceNode = DataStoreReferenceNode;
+exports.EndEventNode = EndEventNode;
+exports.GatewayNode = GatewayNode;
+exports.GroupNode = GroupNode;
+exports.IntermediateCatchEventNode = IntermediateCatchEventNode;
+exports.IntermediateThrowEventNode = IntermediateThrowEventNode;
+exports.LaneNode = LaneNode;
+exports.MessageFlowEdge = MessageFlowEdge;
+exports.PoolNode = PoolNode;
+exports.SequenceFlowEdge = SequenceFlowEdge;
+exports.StartEventNode = StartEventNode;
+exports.SubChoreographyNode = SubChoreographyNode;
+exports.SubConversationNode = SubConversationNode;
+exports.SubProcessNode = SubProcessNode;
+exports.TaskNode = TaskNode;
+exports.acceptsBoundaryEvents = acceptsBoundaryEvents;
+exports.createPreviewAdapter = createPreviewAdapter;
+exports.createSimulation = createSimulation;
+exports.fire = fire;
+exports.getElementMeta = getElementMeta;
+exports.getFireable = getFireable;
+exports.getHandlePolicy = getHandlePolicy;
+exports.getOrientation = getOrientation;
+exports.isChoreographyType = isChoreographyType;
+exports.isCompleted = isCompleted;
+exports.isContainerType = isContainerType;
+exports.isConversationType = isConversationType;
+exports.isDataType = isDataType;
+exports.isEventType = isEventType;
+exports.isGatewayType = isGatewayType;
+exports.isTaskType = isTaskType;
+exports.parseBpmnXml = parseBpmnXml;
+exports.serializeBpmnXml = serializeBpmnXml;
+exports.setVariable = setVariable;
+exports.supportsCollapse = supportsCollapse;
+exports.supportsMarkers = supportsMarkers;
+exports.tick = tick;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map