@aranzatech/diagrams-bpmn 0.2.0 → 0.2.1

package/dist/validation/index.cjs

@@ -0,0 +1,848 @@
+'use strict';
+
+// src/elements/catalog.ts
+var BPMN_ELEMENT_CATALOG = {
+  // ─── Events ──────────────────────────────────────────────────────────────────
+  StartEvent: {
+    label: "Start Event",
+    icon: "Circle",
+    category: "event",
+    defaultWidth: 36,
+    defaultHeight: 36,
+    handlePolicy: "source",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    eventSemantics: "start",
+    canBeStart: true,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 1
+  },
+  EndEvent: {
+    label: "End Event",
+    icon: "CircleDot",
+    category: "event",
+    defaultWidth: 36,
+    defaultHeight: 36,
+    handlePolicy: "target",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    eventSemantics: "end",
+    canBeStart: false,
+    canBeEnd: true,
+    maxOutgoing: 0
+  },
+  IntermediateCatchEvent: {
+    label: "Intermediate Catch Event",
+    icon: "Clock3",
+    category: "event",
+    defaultWidth: 36,
+    defaultHeight: 36,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    eventSemantics: "intermediateCatch",
+    canBeStart: false,
+    canBeEnd: false
+  },
+  IntermediateThrowEvent: {
+    label: "Intermediate Throw Event",
+    icon: "Send",
+    category: "event",
+    defaultWidth: 36,
+    defaultHeight: 36,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    eventSemantics: "intermediateThrow",
+    canBeStart: false,
+    canBeEnd: false
+  },
+  BoundaryEvent: {
+    label: "Boundary Event",
+    icon: "AlarmClock",
+    category: "event",
+    defaultWidth: 36,
+    defaultHeight: 36,
+    handlePolicy: "source",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    eventSemantics: "boundary",
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0
+  },
+  // ─── Tasks ───────────────────────────────────────────────────────────────────
+  Task: {
+    label: "Task",
+    icon: "CheckSquare",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  UserTask: {
+    label: "User Task",
+    icon: "UserRound",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  ServiceTask: {
+    label: "Service Task",
+    icon: "Cog",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  ScriptTask: {
+    label: "Script Task",
+    icon: "FileCode",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  ManualTask: {
+    label: "Manual Task",
+    icon: "Hand",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  BusinessRuleTask: {
+    label: "Business Rule Task",
+    icon: "Table2",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  ReceiveTask: {
+    label: "Receive Task",
+    icon: "Inbox",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  SendTask: {
+    label: "Send Task",
+    icon: "Send",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  CallActivity: {
+    label: "Call Activity",
+    icon: "ExternalLink",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  // ─── Gateways ────────────────────────────────────────────────────────────────
+  ExclusiveGateway: {
+    label: "Exclusive Gateway",
+    icon: "X",
+    category: "gateway",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  InclusiveGateway: {
+    label: "Inclusive Gateway",
+    icon: "Circle",
+    category: "gateway",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  ParallelGateway: {
+    label: "Parallel Gateway",
+    icon: "Plus",
+    category: "gateway",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  EventBasedGateway: {
+    label: "Event-Based Gateway",
+    icon: "Radio",
+    category: "gateway",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 1
+  },
+  ComplexGateway: {
+    label: "Complex Gateway",
+    icon: "Asterisk",
+    category: "gateway",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  // ─── Containers ───────────────────────────────────────────────────────────────
+  SubProcess: {
+    label: "Sub-Process",
+    icon: "PlusSquare",
+    category: "container",
+    defaultWidth: 350,
+    defaultHeight: 200,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: true,
+    acceptsBoundaryEvents: true,
+    supportsCollapse: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  Transaction: {
+    label: "Transaction",
+    icon: "Receipt",
+    category: "container",
+    defaultWidth: 350,
+    defaultHeight: 200,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: true,
+    acceptsBoundaryEvents: true,
+    supportsCollapse: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  EventSubProcess: {
+    label: "Event Sub-Process",
+    icon: "CircleDotDashed",
+    category: "container",
+    defaultWidth: 350,
+    defaultHeight: 200,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: true,
+    acceptsBoundaryEvents: false,
+    supportsCollapse: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  AdHocSubProcess: {
+    label: "Ad-Hoc Sub-Process",
+    icon: "Waves",
+    category: "container",
+    defaultWidth: 350,
+    defaultHeight: 200,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: true,
+    acceptsBoundaryEvents: true,
+    supportsCollapse: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  Pool: {
+    label: "Pool",
+    icon: "Rows3",
+    category: "container",
+    defaultWidth: 600,
+    defaultHeight: 200,
+    handlePolicy: "none",
+    orientation: "horizontal",
+    isContainer: true,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  Lane: {
+    label: "Lane",
+    icon: "PanelTop",
+    category: "container",
+    defaultWidth: 600,
+    defaultHeight: 120,
+    handlePolicy: "none",
+    orientation: "horizontal",
+    isContainer: true,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  // ─── Artifacts ────────────────────────────────────────────────────────────────
+  Annotation: {
+    label: "Text Annotation",
+    icon: "StickyNote",
+    category: "artifact",
+    defaultWidth: 100,
+    defaultHeight: 60,
+    handlePolicy: "none",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  Group: {
+    label: "Group",
+    icon: "Group",
+    category: "artifact",
+    defaultWidth: 300,
+    defaultHeight: 200,
+    handlePolicy: "none",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  // ─── Data (BPMN 2.0 §10.3) ───────────────────────────────────────────────────
+  DataObject: {
+    label: "Data Object",
+    icon: "File",
+    category: "data",
+    defaultWidth: 36,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  DataObjectReference: {
+    label: "Data Object Reference",
+    icon: "FileSymlink",
+    category: "data",
+    defaultWidth: 36,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  DataInput: {
+    label: "Data Input",
+    icon: "FileInput",
+    category: "data",
+    defaultWidth: 36,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0
+  },
+  DataOutput: {
+    label: "Data Output",
+    icon: "FileOutput",
+    category: "data",
+    defaultWidth: 36,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxOutgoing: 0
+  },
+  DataStore: {
+    label: "Data Store",
+    icon: "Database",
+    category: "data",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  DataStoreReference: {
+    label: "Data Store Reference",
+    icon: "DatabaseZap",
+    category: "data",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  // ─── Conversation (BPMN 2.0 §12) ─────────────────────────────────────────────
+  Conversation: {
+    label: "Conversation",
+    icon: "MessageCircle",
+    category: "conversation",
+    defaultWidth: 60,
+    defaultHeight: 52,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  SubConversation: {
+    label: "Sub-Conversation",
+    icon: "MessagesSquare",
+    category: "conversation",
+    defaultWidth: 60,
+    defaultHeight: 52,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: true,
+    acceptsBoundaryEvents: false,
+    supportsCollapse: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  CallConversation: {
+    label: "Call Conversation",
+    icon: "PhoneCall",
+    category: "conversation",
+    defaultWidth: 60,
+    defaultHeight: 52,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  // ─── Choreography (BPMN 2.0 §11) ─────────────────────────────────────────────
+  ChoreographyTask: {
+    label: "Choreography Task",
+    icon: "ArrowLeftRight",
+    category: "choreography",
+    defaultWidth: 120,
+    defaultHeight: 80,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  SubChoreography: {
+    label: "Sub-Choreography",
+    icon: "BoxSelect",
+    category: "choreography",
+    defaultWidth: 120,
+    defaultHeight: 80,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: true,
+    acceptsBoundaryEvents: false,
+    supportsCollapse: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  CallChoreography: {
+    label: "Call Choreography",
+    icon: "Phone",
+    category: "choreography",
+    defaultWidth: 120,
+    defaultHeight: 80,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  }
+};
+var BPMN_RESIZABLE_ELEMENT_TYPES = [
+  "Task",
+  "UserTask",
+  "ServiceTask",
+  "ScriptTask",
+  "ManualTask",
+  "BusinessRuleTask",
+  "ReceiveTask",
+  "SendTask",
+  "CallActivity",
+  "SubProcess",
+  "Transaction",
+  "EventSubProcess",
+  "AdHocSubProcess",
+  "Pool",
+  "Lane",
+  "Annotation",
+  "Group",
+  "SubConversation",
+  "ChoreographyTask",
+  "SubChoreography",
+  "CallChoreography"
+];
+new Set(BPMN_RESIZABLE_ELEMENT_TYPES);
+
+// src/elements/guards.ts
+var GATEWAY_TYPES = /* @__PURE__ */ new Set([
+  "ExclusiveGateway",
+  "InclusiveGateway",
+  "ParallelGateway",
+  "EventBasedGateway",
+  "ComplexGateway"
+]);
+var EVENT_TYPES = /* @__PURE__ */ new Set([
+  "StartEvent",
+  "EndEvent",
+  "IntermediateCatchEvent",
+  "IntermediateThrowEvent",
+  "BoundaryEvent"
+]);
+var DATA_TYPES = /* @__PURE__ */ new Set([
+  "DataObject",
+  "DataObjectReference",
+  "DataInput",
+  "DataOutput",
+  "DataStore",
+  "DataStoreReference"
+]);
+function isGatewayType(type) {
+  return GATEWAY_TYPES.has(type);
+}
+function isEventType(type) {
+  return EVENT_TYPES.has(type);
+}
+function isDataType(type) {
+  return DATA_TYPES.has(type);
+}
+
+// src/validation/index.ts
+function isFlowNode(type) {
+  return isEventType(type) || isGatewayType(type) || type.includes("Task") || type === "CallActivity" || type === "SubProcess" || type === "Transaction" || type === "EventSubProcess" || type === "AdHocSubProcess" || type === "ChoreographyTask" || type === "SubChoreography" || type === "CallChoreography";
+}
+function isProcessNode(type) {
+  return isFlowNode(type) && type !== "BoundaryEvent";
+}
+function isSubProcess(type) {
+  return type === "SubProcess" || type === "Transaction" || type === "EventSubProcess" || type === "AdHocSubProcess";
+}
+function isCatchTarget(type) {
+  return type === "IntermediateCatchEvent" || type === "ReceiveTask";
+}
+function poolAncestor(node, nodeById) {
+  let current = node;
+  const visited = /* @__PURE__ */ new Set();
+  while (current?.parentId && !visited.has(current.id)) {
+    visited.add(current.id);
+    const parent = nodeById.get(current.parentId);
+    if (parent?.data.elementType === "Pool") return parent.id;
+    current = parent;
+  }
+  return void 0;
+}
+function countSequenceEdges(edges, nodeId, direction) {
+  return edges.filter((edge) => {
+    if (edge.data?.edgeType !== "sequenceFlow") return false;
+    return direction === "in" ? edge.target === nodeId : edge.source === nodeId;
+  }).length;
+}
+function sequenceEdges(edges) {
+  return edges.filter((edge) => (edge.data?.edgeType ?? edge.type) === "sequenceFlow");
+}
+function sequenceOut(edges, nodeId) {
+  return sequenceEdges(edges).filter((edge) => edge.source === nodeId);
+}
+function sequenceIn(edges, nodeId) {
+  return sequenceEdges(edges).filter((edge) => edge.target === nodeId);
+}
+function issue(code, severity, message, elementId, relatedElementIds) {
+  return {
+    id: `${code}:${elementId ?? relatedElementIds?.join(",") ?? "diagram"}`,
+    code,
+    severity,
+    message,
+    ...elementId ? { elementId } : {},
+    ...relatedElementIds ? { relatedElementIds } : {}
+  };
+}
+function validateBpmnDiagram(nodes, edges, options = {}) {
+  const opts = {
+    requireStartEvent: true,
+    requireEndEvent: true,
+    strictNames: false,
+    ...options
+  };
+  const issues = [];
+  const nodeById = new Map(nodes.map((node) => [node.id, node]));
+  const seqEdges = sequenceEdges(edges);
+  const processNodes = nodes.filter((node) => isProcessNode(node.data.elementType));
+  if (opts.requireStartEvent && !processNodes.some((node) => node.data.elementType === "StartEvent")) {
+    issues.push(issue("bpmn/start-event-required", "error", "The diagram must contain at least one start event."));
+  }
+  if (opts.requireEndEvent && !processNodes.some((node) => node.data.elementType === "EndEvent")) {
+    issues.push(issue("bpmn/end-event-required", "error", "The diagram must contain at least one end event."));
+  }
+  for (const edge of edges) {
+    const edgeType = edge.data?.edgeType ?? edge.type;
+    const source = nodeById.get(edge.source);
+    const target = nodeById.get(edge.target);
+    if (!source || !target) {
+      issues.push(issue(
+        "bpmn/no-orphan-edges",
+        "error",
+        `Edge "${edge.id}" references a missing ${!source ? "source" : "target"} node.`,
+        edge.id,
+        [edge.source, edge.target]
+      ));
+      continue;
+    }
+    if (edge.source === edge.target) {
+      issues.push(issue("bpmn/no-self-loop", "error", "BPMN edges cannot connect an element to itself.", edge.id, [edge.source]));
+    }
+    if (edgeType === "sequenceFlow") {
+      if (!isFlowNode(source.data.elementType) || !isFlowNode(target.data.elementType) || isDataType(source.data.elementType) || isDataType(target.data.elementType)) {
+        issues.push(issue("bpmn/sequence-flow-valid-endpoints", "error", "Sequence flows must connect BPMN flow nodes.", edge.id, [source.id, target.id]));
+      }
+      const sourcePool = poolAncestor(source, nodeById);
+      const targetPool = poolAncestor(target, nodeById);
+      if (sourcePool && targetPool && sourcePool !== targetPool) {
+        issues.push(issue("bpmn/sequence-flow-no-cross-pool", "error", "Sequence flows cannot cross pools. Use message flow between participants.", edge.id, [source.id, target.id]));
+      }
+    }
+    if (edgeType === "messageFlow") {
+      const sourcePool = poolAncestor(source, nodeById);
+      const targetPool = poolAncestor(target, nodeById);
+      if (!sourcePool || !targetPool || sourcePool === targetPool) {
+        issues.push(issue("bpmn/message-flow-valid-endpoints", "error", "Message flows must connect flow nodes in different pools.", edge.id, [source.id, target.id]));
+      }
+      if (!isFlowNode(source.data.elementType) || !isFlowNode(target.data.elementType)) {
+        issues.push(issue("bpmn/message-flow-valid-endpoints", "error", "Message flows must connect BPMN flow nodes, not containers.", edge.id, [source.id, target.id]));
+      }
+    }
+    if (edgeType === "dataAssociation") {
+      const hasDataEndpoint = isDataType(source.data.elementType) || isDataType(target.data.elementType);
+      const hasFlowEndpoint = isFlowNode(source.data.elementType) || isFlowNode(target.data.elementType);
+      if (!hasDataEndpoint || !hasFlowEndpoint) {
+        issues.push(issue("bpmn/data-association-valid-endpoints", "error", "Data associations must connect data elements with flow nodes.", edge.id, [source.id, target.id]));
+      }
+    }
+  }
+  const duplicateSequenceKeys = /* @__PURE__ */ new Set();
+  const reportedDuplicateKeys = /* @__PURE__ */ new Set();
+  for (const edge of seqEdges) {
+    const key = `${edge.source}->${edge.target}`;
+    if (duplicateSequenceKeys.has(key) && !reportedDuplicateKeys.has(key)) {
+      reportedDuplicateKeys.add(key);
+      issues.push(issue("bpmn/no-duplicate-sequence-flow", "error", "Only one sequence flow is allowed between the same source and target.", edge.id, [edge.source, edge.target]));
+    }
+    duplicateSequenceKeys.add(key);
+  }
+  for (const node of nodes) {
+    const type = node.data.elementType;
+    const incoming = countSequenceEdges(edges, node.id, "in");
+    const outgoing = countSequenceEdges(edges, node.id, "out");
+    const meta = BPMN_ELEMENT_CATALOG[type];
+    if (type === "StartEvent" && incoming > 0) {
+      issues.push(issue("bpmn/start-event-no-incoming", "error", "Start events cannot have incoming sequence flows.", node.id));
+    }
+    if (type === "EndEvent") {
+      if (outgoing > 0) issues.push(issue("bpmn/no-outgoing-from-end-event", "error", "End events cannot have outgoing sequence flows.", node.id));
+      if (incoming === 0) issues.push(issue("bpmn/end-event-has-incoming", "error", "End events should have at least one incoming sequence flow.", node.id));
+    }
+    if ((type === "IntermediateCatchEvent" || type === "IntermediateThrowEvent") && (incoming === 0 || outgoing === 0)) {
+      issues.push(issue("bpmn/intermediate-event-both-flows", "error", "Intermediate events should have both incoming and outgoing sequence flows.", node.id));
+    }
+    if (type === "BoundaryEvent") {
+      const hostId = node.data.attachedToRef ?? node.parentId;
+      const host = hostId ? nodeById.get(hostId) : void 0;
+      if (!host || !BPMN_ELEMENT_CATALOG[host.data.elementType]?.acceptsBoundaryEvents) {
+        issues.push(issue("bpmn/boundary-event-attached", "error", "Boundary events must be attached to an activity or subprocess.", node.id, hostId ? [hostId] : void 0));
+      }
+      if (sequenceIn(edges, node.id).length > 0) {
+        issues.push(issue("bpmn/boundary-no-incoming", "error", "Boundary events cannot have incoming sequence flows.", node.id));
+      }
+      if (sequenceOut(edges, node.id).length === 0) {
+        issues.push(issue("bpmn/boundary-has-outgoing", "warning", "Boundary events should define an outgoing exception path.", node.id));
+      }
+    }
+    if (isGatewayType(type)) {
+      if (incoming === 0) issues.push(issue("bpmn/gateway-has-incoming", "error", "Gateways should have at least one incoming sequence flow.", node.id));
+      if (outgoing === 0) issues.push(issue("bpmn/gateway-has-outgoing", "error", "Gateways should have at least one outgoing sequence flow.", node.id));
+    }
+    if (type === "ExclusiveGateway" || type === "InclusiveGateway" || type === "ComplexGateway") {
+      const outgoingEdges = sequenceOut(edges, node.id);
+      const defaults = outgoingEdges.filter((edge) => edge.data?.isDefault);
+      if (defaults.length > 1) {
+        issues.push(issue("bpmn/gateway-single-default", "error", "Gateways can have at most one default sequence flow.", node.id, defaults.map((edge) => edge.id)));
+      }
+      if (outgoingEdges.length >= 2) {
+        for (const edge of outgoingEdges) {
+          if (!edge.data?.isDefault && !edge.data?.conditionExpression) {
+            issues.push(issue("bpmn/gateway-condition", "error", "Conditional gateway branches should have a condition or be marked as default.", edge.id, [node.id, edge.target]));
+          }
+        }
+      }
+    }
+    if (type === "EventBasedGateway") {
+      const outgoingEdges = edges.filter((edge) => edge.data?.edgeType === "sequenceFlow" && edge.source === node.id);
+      if (outgoingEdges.length < 2) {
+        issues.push(issue("bpmn/event-based-gateway-min-outgoing", "error", "Event-based gateways should have at least two outgoing sequence flows.", node.id));
+      }
+      for (const edge of outgoingEdges) {
+        const target = nodeById.get(edge.target);
+        if (target && !isCatchTarget(target.data.elementType)) {
+          issues.push(issue("bpmn/event-based-gateway-valid-targets", "error", "Event-based gateways must target catch events or receive tasks.", edge.id, [node.id, target.id]));
+        }
+      }
+    }
+    if (meta.maxIncoming !== void 0 && incoming > meta.maxIncoming) {
+      issues.push(issue("bpmn/max-incoming", "error", `${type} cannot have more than ${meta.maxIncoming} incoming sequence flow(s).`, node.id));
+    }
+    if (meta.maxOutgoing !== void 0 && outgoing > meta.maxOutgoing) {
+      issues.push(issue("bpmn/max-outgoing", "error", `${type} cannot have more than ${meta.maxOutgoing} outgoing sequence flow(s).`, node.id));
+    }
+    if (opts.strictNames && (type.includes("Task") || isGatewayType(type)) && !node.data.label) {
+      issues.push(issue("bpmn/name-required", "warning", `${type} should have a label.`, node.id));
+    }
+    if (isSubProcess(type)) {
+      const childNodes = nodes.filter((child) => child.parentId === node.id);
+      if (childNodes.length > 0) {
+        if (!childNodes.some((child) => child.data.elementType === "StartEvent")) {
+          issues.push(issue("bpmn/subprocess-has-start-end", "error", "Expanded subprocesses should contain a start event.", node.id));
+        }
+        if (!childNodes.some((child) => child.data.elementType === "EndEvent")) {
+          issues.push(issue("bpmn/subprocess-has-start-end", "error", "Expanded subprocesses should contain an end event.", node.id));
+        }
+      }
+      if (type === "EventSubProcess") {
+        const starts = childNodes.filter((child) => child.data.elementType === "StartEvent");
+        for (const start of starts) {
+          if (!start.data.trigger || start.data.trigger === "none") {
+            issues.push(issue("bpmn/event-subprocess-triggered-start", "error", "Event subprocess start events must define an event trigger.", start.id, [node.id]));
+          }
+        }
+      }
+    }
+    if (type === "Lane") {
+      const parent = node.parentId ? nodeById.get(node.parentId) : void 0;
+      if (parent?.data.elementType !== "Pool") {
+        issues.push(issue("bpmn/lane-parent-pool", "error", "Lanes must be contained by a pool.", node.id));
+      }
+    }
+  }
+  return {
+    valid: issues.every((item) => item.severity !== "error"),
+    issues
+  };
+}
+
+exports.validateBpmnDiagram = validateBpmnDiagram;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map