@bpmn-nova/studio 0.3.0-preview → 0.3.2-preview

package/dist/modules/bpmn-model/index.js

@@ -0,0 +1,703 @@
+import {
+  applyContainmentOperation,
+  createEmptyProcess,
+  createNode,
+  createEdge,
+  NODE_DEFINITIONS,
+  edgeWaypoints,
+  elementScopeId,
+  isEmbeddedSubProcess,
+} from '../core/index.js';
+import { flowableProfile } from '../engine-flowable/index.js';
+import { activitiProfile } from '../engine-activiti/index.js';
+
+const NS = {
+  bpmn: 'http://www.omg.org/spec/BPMN/20100524/MODEL',
+  bpmndi: 'http://www.omg.org/spec/BPMN/20100524/DI',
+  dc: 'http://www.omg.org/spec/DD/20100524/DC',
+  di: 'http://www.omg.org/spec/DD/20100524/DI',
+  xsi: 'http://www.w3.org/2001/XMLSchema-instance',
+};
+
+const EVENT_DEF_BY_LOCAL = {
+  messageEventDefinition: 'message',
+  timerEventDefinition: 'timer',
+  conditionalEventDefinition: 'conditional',
+  signalEventDefinition: 'signal',
+  errorEventDefinition: 'error',
+  escalationEventDefinition: 'escalation',
+  cancelEventDefinition: 'cancel',
+  compensateEventDefinition: 'compensate',
+  terminateEventDefinition: 'terminate',
+  linkEventDefinition: 'link',
+};
+const EVENT_LOCAL_BY_DEF = Object.fromEntries(Object.entries(EVENT_DEF_BY_LOCAL).map(([local, def]) => [def, local]));
+
+const DIRECT_TYPE_BY_LOCAL = {
+  task: 'task',
+  userTask: 'userTask',
+  manualTask: 'manualTask',
+  serviceTask: 'serviceTask',
+  scriptTask: 'scriptTask',
+  businessRuleTask: 'businessRuleTask',
+  sendTask: 'sendTask',
+  receiveTask: 'receiveTask',
+  callActivity: 'callActivity',
+  exclusiveGateway: 'exclusiveGateway',
+  parallelGateway: 'parallelGateway',
+  inclusiveGateway: 'inclusiveGateway',
+  eventBasedGateway: 'eventBasedGateway',
+  complexGateway: 'complexGateway',
+  transaction: 'transaction',
+  adHocSubProcess: 'adHocSubProcess',
+  dataObjectReference: 'dataObjectReference',
+  dataStoreReference: 'dataStoreReference',
+  textAnnotation: 'textAnnotation',
+  group: 'group',
+};
+
+const EVENT_TYPE_INDEX = {};
+for (const [type, def] of Object.entries(NODE_DEFINITIONS)) {
+  if (!def?.eventStage) continue;
+  const key = `${def.localName}|${def.eventDefinition || 'none'}`;
+  EVENT_TYPE_INDEX[key] = type;
+}
+
+export const engineProfiles = { flowable: flowableProfile, activiti: activitiProfile };
+
+export function detectEngineFromXml(xml) {
+  if (/xmlns:flowable\s*=/.test(xml) || /flowable:/.test(xml)) return 'flowable';
+  if (/xmlns:activiti\s*=/.test(xml) || /activiti:/.test(xml)) return 'activiti';
+  return 'flowable';
+}
+function getProfile(engine) { return engineProfiles[engine] || flowableProfile; }
+
+function elementEventDefinition(el) {
+  const child = Array.from(el.children || []).find((item) => item.localName?.endsWith('EventDefinition'));
+  return child ? (EVENT_DEF_BY_LOCAL[child.localName] || null) : null;
+}
+
+function inferType(el) {
+  if (['startEvent', 'endEvent', 'intermediateCatchEvent', 'intermediateThrowEvent', 'boundaryEvent'].includes(el.localName)) {
+    const eventDef = elementEventDefinition(el) || 'none';
+    return EVENT_TYPE_INDEX[`${el.localName}|${eventDef}`] || EVENT_TYPE_INDEX[`${el.localName}|none`] || 'generic';
+  }
+  if (el.localName === 'subProcess') return el.getAttribute('triggeredByEvent') === 'true' ? 'eventSubProcess' : 'subProcess';
+  return DIRECT_TYPE_BY_LOCAL[el.localName] || 'generic';
+}
+
+function readShapeMaps(doc) {
+  const shapeMap = new Map();
+  for (const shape of Array.from(doc.getElementsByTagNameNS(NS.bpmndi, 'BPMNShape'))) {
+    const elementId = shape.getAttribute('bpmnElement');
+    const bounds = Array.from(shape.children).find((el) => el.localName === 'Bounds');
+    if (!elementId || !bounds) continue;
+    shapeMap.set(elementId, {
+      x: Number(bounds.getAttribute('x') || 0),
+      y: Number(bounds.getAttribute('y') || 0),
+      width: Number(bounds.getAttribute('width') || 0),
+      height: Number(bounds.getAttribute('height') || 0),
+      isExpanded: shape.getAttribute('isExpanded') !== 'false',
+    });
+  }
+  const edgeDiMap = new Map();
+  for (const edgeDi of Array.from(doc.getElementsByTagNameNS(NS.bpmndi, 'BPMNEdge'))) {
+    const elementId = edgeDi.getAttribute('bpmnElement');
+    const points = Array.from(edgeDi.children)
+      .filter((el) => el.localName === 'waypoint')
+      .map((p) => ({ x: Number(p.getAttribute('x') || 0), y: Number(p.getAttribute('y') || 0) }));
+    if (elementId && points.length) edgeDiMap.set(elementId, points);
+  }
+  return { shapeMap, edgeDiMap };
+}
+
+function parseEventProperties(el, def) {
+  const props = {};
+  if (def.kind === 'boundary') {
+    props.attachedToRef = el.getAttribute('attachedToRef') || '';
+    props.cancelActivity = el.getAttribute('cancelActivity') !== 'false';
+  }
+  const eventDefinition = Array.from(el.children).find((child) => child.localName?.endsWith('EventDefinition'));
+  if (!eventDefinition) return props;
+  if (def.eventDefinition === 'timer') {
+    const timer = Array.from(eventDefinition.children).find((child) => ['timeDate', 'timeDuration', 'timeCycle'].includes(child.localName));
+    if (timer) {
+      props.timerType = ({ timeDate: 'date', timeDuration: 'duration', timeCycle: 'cycle' })[timer.localName] || 'duration';
+      props.timerValue = timer.textContent?.trim() || '';
+    }
+  }
+  if (def.eventDefinition === 'conditional') {
+    const condition = Array.from(eventDefinition.children).find((child) => child.localName === 'condition');
+    props.condition = condition?.textContent?.trim() || '';
+  }
+  const refAttr = ({ message: 'messageRef', signal: 'signalRef', error: 'errorRef', escalation: 'escalationRef', link: 'name' })[def.eventDefinition];
+  if (refAttr) props.eventRef = eventDefinition.getAttribute(refAttr) || '';
+  if (def.eventDefinition === 'compensate') {
+    props.activityRef = eventDefinition.getAttribute('activityRef') || '';
+    props.waitForCompletion = eventDefinition.getAttribute('waitForCompletion') !== 'false';
+  }
+  return props;
+}
+
+function parseCommonNode(el, profile, shapeMap, fallbackIndex = 0) {
+  const type = inferType(el);
+  const def = NODE_DEFINITIONS[type] || NODE_DEFINITIONS.generic;
+  const id = el.getAttribute('id') || `Imported_${fallbackIndex + 1}`;
+  const bounds = shapeMap.get(id) || { x: 120 + fallbackIndex * 260, y: 220, width: def.width, height: def.height };
+  const properties = {
+    ...profile.parseNode(el),
+    ...parseEventProperties(el, def),
+  };
+  properties.documentation = Array.from(el.children || []).find((child) => child.localName === 'documentation')?.textContent || properties.documentation || '';
+  if (def.kind === 'gateway') properties.gatewayDirection = el.getAttribute('gatewayDirection') || properties.gatewayDirection || 'Unspecified';
+  if (type === 'eventBasedGateway') {
+    properties.instantiate = el.getAttribute('instantiate') === 'true';
+    properties.eventGatewayType = el.getAttribute('eventGatewayType') || 'Exclusive';
+  }
+  if (type === 'adHocSubProcess') {
+    properties.ordering = el.getAttribute('ordering') || 'Parallel';
+    properties.cancelRemainingInstances = el.getAttribute('cancelRemainingInstances') !== 'false';
+    properties.adHocCompletionCondition = Array.from(el.children || []).find((child) => child.localName === 'completionCondition')?.textContent?.trim() || '';
+  }
+  if (type === 'complexGateway') properties.activationCondition = Array.from(el.children || []).find((child) => child.localName === 'activationCondition')?.textContent?.trim() || '';
+
+  if (type === 'scriptTask') {
+    properties.scriptFormat = el.getAttribute('scriptFormat') || 'javascript';
+    properties.script = Array.from(el.children).find((child) => child.localName === 'script')?.textContent || '';
+  }
+  if (type === 'callActivity') properties.calledElement = el.getAttribute('calledElement') || '';
+  if (['sendTask', 'receiveTask'].includes(type)) {
+    properties.messageRef = el.getAttribute('messageRef') || '';
+    properties.operationRef = el.getAttribute('operationRef') || '';
+    if (type === 'receiveTask') properties.instantiate = el.getAttribute('instantiate') === 'true';
+  }
+  if ((def.eventStage === 'start' || (def.eventStage === 'intermediate' && def.eventRole === 'catch')) && ['message', 'signal'].includes(def.eventDefinition)) {
+    properties.parallelMultiple = el.getAttribute('parallelMultiple') === 'true';
+  }
+  if (type === 'textAnnotation') {
+    properties.text = Array.from(el.children).find((child) => child.localName === 'text')?.textContent || '';
+    properties.textFormat = el.getAttribute('textFormat') || 'text/plain';
+  }
+  if (type === 'dataObjectReference') properties.dataObjectRef = el.getAttribute('dataObjectRef') || '';
+  if (type === 'dataStoreReference') properties.dataStoreRef = el.getAttribute('dataStoreRef') || '';
+  if (type === 'eventSubProcess') properties.triggeredByEvent = true;
+
+  const loop = Array.from(el.children).find((child) => ['standardLoopCharacteristics', 'multiInstanceLoopCharacteristics'].includes(child.localName));
+  if (loop?.localName === 'standardLoopCharacteristics') {
+    properties.loopType = 'standard';
+    properties.testBefore = loop.getAttribute('testBefore') === 'true';
+    properties.loopMaximum = loop.getAttribute('loopMaximum') || '';
+    properties.loopCondition = Array.from(loop.children || []).find((child) => child.localName === 'loopCondition')?.textContent?.trim() || '';
+  }
+  if (loop?.localName === 'multiInstanceLoopCharacteristics') {
+    properties.loopType = loop.getAttribute('isSequential') === 'true' ? 'sequential' : 'parallel';
+    const getLoop = (name) => loop.getAttributeNS(profile.namespace, name) || loop.getAttribute(`${profile.prefix}:${name}`) || '';
+    properties.collection = getLoop('collection');
+    properties.elementVariable = getLoop('elementVariable');
+    properties.elementIndexVariable = getLoop('elementIndexVariable');
+    properties.loopCardinality = Array.from(loop.children || []).find((child) => child.localName === 'loopCardinality')?.textContent?.trim() || '';
+    properties.completionCondition = Array.from(loop.children || []).find((child) => child.localName === 'completionCondition')?.textContent?.trim() || '';
+  }
+  properties.isForCompensation = el.getAttribute('isForCompensation') === 'true';
+
+  const knownAttrs = new Set(['id', 'name', 'scriptFormat', 'calledElement', 'default', 'attachedToRef', 'cancelActivity', 'triggeredByEvent', 'isForCompensation', 'dataObjectRef', 'dataStoreRef', 'gatewayDirection', 'instantiate', 'eventGatewayType', 'ordering', 'cancelRemainingInstances', 'messageRef', 'operationRef', 'parallelMultiple', 'instantiate', 'textFormat']);
+  const unknownAttributes = [];
+  for (const attr of Array.from(el.attributes || [])) {
+    if (knownAttrs.has(attr.localName)) continue;
+    if (attr.prefix === profile.prefix || attr.namespaceURI === profile.namespace) continue;
+    unknownAttributes.push({ name: attr.name, value: attr.value });
+  }
+
+  properties.extensionAttributes = { ...(properties.extensionAttributes || {}), ...Object.fromEntries(unknownAttributes.filter((attr) => attr.name.includes(':')).map((attr) => [attr.name, attr.value])) };
+
+  const extensionElements = [];
+  const ext = Array.from(el.children || []).find((child) => child.localName === 'extensionElements');
+  if (ext && typeof XMLSerializer !== 'undefined') {
+    const serializer = new XMLSerializer();
+    const handled = new Set(['executionListener', 'taskListener', 'field', 'failedJobRetryTimeCycle']);
+    for (const child of Array.from(ext.children)) {
+      const isEngineHandled = handled.has(child.localName) && (child.prefix === profile.prefix || child.namespaceURI === profile.namespace);
+      if (!isEngineHandled) extensionElements.push(serializer.serializeToString(child));
+    }
+  }
+
+  return createNode(type, bounds.x, bounds.y, {
+    id,
+    name: el.getAttribute('name') || def.label,
+    width: bounds.width || def.width,
+    height: bounds.height || def.height,
+    bpmnType: def.bpmnType,
+    originalLocalName: el.localName,
+    properties,
+    unknownAttributes,
+    extensionElements,
+    defaultFlowId: el.getAttribute('default') || '',
+  });
+}
+
+export function importBpmn(xml, engineHint) {
+  if (typeof DOMParser === 'undefined') throw new Error('importBpmn currently requires a browser DOMParser.');
+  const doc = new DOMParser().parseFromString(xml, 'application/xml');
+  const parserError = doc.querySelector('parsererror');
+  if (parserError) throw new Error(`BPMN XML 解析失败: ${parserError.textContent.trim()}`);
+
+  const definitions = doc.documentElement;
+  const engine = engineHint || detectEngineFromXml(xml);
+  const profile = getProfile(engine);
+  const process = Array.from(definitions.children).find((el) => el.localName === 'process');
+  if (!process) throw new Error('未找到 <process> 元素。');
+
+  const model = createEmptyProcess(engine);
+  model.id = process.getAttribute('id') || 'Process_1';
+  model.name = process.getAttribute('name') || model.id;
+  model.isExecutable = process.getAttribute('isExecutable') !== 'false';
+  model.targetNamespace = definitions.getAttribute('targetNamespace') || model.targetNamespace;
+  model.properties = { ...(model.properties || {}), ...(profile.parseProcess?.(process) || {}) };
+  model.properties.documentation = Array.from(process.children || []).find((child) => child.localName === 'documentation')?.textContent || model.properties.documentation || '';
+  model.properties.extensionAttributes = { ...(model.properties.extensionAttributes || {}) };
+  for (const attr of Array.from(process.attributes || [])) {
+    if (['id', 'name', 'isExecutable'].includes(attr.localName)) continue;
+    if (attr.prefix === profile.prefix || attr.namespaceURI === profile.namespace) continue;
+    if (attr.name.includes(':')) model.properties.extensionAttributes[attr.name] = attr.value;
+  }
+  model.extensionElements = [];
+  const processExt = Array.from(process.children || []).find((child) => child.localName === 'extensionElements');
+  if (processExt && typeof XMLSerializer !== 'undefined') {
+    const serializer = new XMLSerializer();
+    for (const child of Array.from(processExt.children || [])) {
+      const handled = child.localName === 'executionListener' && (child.prefix === profile.prefix || child.namespaceURI === profile.namespace);
+      if (!handled) model.extensionElements.push(serializer.serializeToString(child));
+    }
+  }
+  model.resources = { messages: [], signals: [], errors: [], escalations: [] };
+  for (const child of Array.from(definitions.children || [])) {
+    const map = { message: 'messages', signal: 'signals', error: 'errors', escalation: 'escalations' };
+    const bucket = map[child.localName];
+    if (!bucket) continue;
+    const item = { id: child.getAttribute('id') || '', name: child.getAttribute('name') || '' };
+    if (child.localName === 'error') item.errorCode = child.getAttribute('errorCode') || '';
+    if (child.localName === 'escalation') item.escalationCode = child.getAttribute('escalationCode') || '';
+    model.resources[bucket].push(item);
+  }
+  model.namespaceDeclarations = {};
+  for (const attr of Array.from(definitions.attributes)) {
+    if (attr.name.startsWith('xmlns:') && !['xmlns:bpmn', 'xmlns:bpmndi', 'xmlns:dc', 'xmlns:di', 'xmlns:xsi', `xmlns:${profile.prefix}`].includes(attr.name)) {
+      model.namespaceDeclarations[attr.name] = attr.value;
+    }
+  }
+
+  const { shapeMap, edgeDiMap } = readShapeMaps(doc);
+  const categoryValues = new Map(
+    Array.from(definitions.getElementsByTagNameNS(NS.bpmn, 'categoryValue'))
+      .map((element) => [element.getAttribute('id'), element.getAttribute('value') || '']),
+  );
+  const groupElements = new Map(
+    Array.from(process.getElementsByTagNameNS(NS.bpmn, 'group'))
+      .map((element) => [element.getAttribute('id'), element]),
+  );
+  const sequenceEls = [];
+  const associationEls = [];
+  const skipLocals = new Set(['extensionElements', 'documentation', 'laneSet', 'dataObject', 'incoming', 'outgoing', 'completionCondition', 'standardLoopCharacteristics', 'multiInstanceLoopCharacteristics', 'ioSpecification', 'property']);
+
+  const collectScope = (container, scopeId) => {
+    for (const el of Array.from(container.children || [])) {
+      if (el.localName === 'sequenceFlow') { sequenceEls.push({ el, scopeId }); continue; }
+      if (el.localName === 'association') { associationEls.push({ el, scopeId }); continue; }
+      if (skipLocals.has(el.localName)) continue;
+      const node = parseCommonNode(el, profile, shapeMap, model.nodes.length);
+      node.scopeId = scopeId;
+      if (isEmbeddedSubProcess(node)) node.isExpanded = false;
+      model.nodes.push(node);
+      if (isEmbeddedSubProcess(node)) collectScope(el, node.id);
+    }
+  };
+  collectScope(process, model.id);
+
+  for (const group of model.nodes.filter((node) => node.type === 'group')) {
+    const element = groupElements.get(group.id);
+    group.properties.categoryValue = categoryValues.get(element?.getAttribute('categoryValueRef')) || '';
+  }
+
+  for (const lane of Array.from(process.querySelectorAll(':scope > laneSet > lane'))) {
+    const node = parseCommonNode(lane, profile, shapeMap, model.nodes.length);
+    node.type = 'lane'; node.bpmnType = 'bpmn:Lane'; node.originalLocalName = 'lane';
+    node.scopeId = model.id;
+    node.properties.flowNodeRefs = Array.from(lane.children).filter((child) => child.localName === 'flowNodeRef').map((child) => child.textContent.trim());
+    model.nodes.push(node);
+  }
+
+  const collaboration = Array.from(definitions.children).find((el) => el.localName === 'collaboration');
+  if (collaboration) {
+    for (const participant of Array.from(collaboration.children).filter((el) => el.localName === 'participant')) {
+      const node = parseCommonNode(participant, profile, shapeMap, model.nodes.length);
+      node.type = 'participant'; node.bpmnType = 'bpmn:Participant'; node.originalLocalName = 'participant';
+      node.scopeId = model.id;
+      node.properties.processRef = participant.getAttribute('processRef') || '';
+      model.nodes.push(node);
+    }
+    for (const el of Array.from(collaboration.children).filter((item) => item.localName === 'messageFlow')) associationEls.push({ el, scopeId: model.id });
+  }
+
+  for (const { el, scopeId } of sequenceEls) {
+    const id = el.getAttribute('id') || `Flow_${model.edges.length + 1}`;
+    const condition = Array.from(el.children).find((child) => child.localName === 'conditionExpression');
+    const source = el.getAttribute('sourceRef') || '';
+    const sourceNode = model.nodes.find((n) => n.id === source);
+    const edgeProperties = profile.parseEdge?.(el) || {};
+    const edgeUnknownAttributes = [];
+    for (const attr of Array.from(el.attributes || [])) {
+      if (['id', 'name', 'sourceRef', 'targetRef'].includes(attr.localName)) continue;
+      if (attr.prefix === profile.prefix || attr.namespaceURI === profile.namespace) continue;
+      edgeUnknownAttributes.push({ name: attr.name, value: attr.value });
+    }
+    edgeProperties.extensionAttributes = { ...(edgeProperties.extensionAttributes || {}), ...Object.fromEntries(edgeUnknownAttributes.filter((attr) => attr.name.includes(':')).map((attr) => [attr.name, attr.value])) };
+    const edgeExtensionElements = [];
+    const edgeExt = Array.from(el.children || []).find((child) => child.localName === 'extensionElements');
+    if (edgeExt && typeof XMLSerializer !== 'undefined') {
+      const serializer = new XMLSerializer();
+      for (const child of Array.from(edgeExt.children || [])) {
+        const handled = child.localName === 'executionListener' && (child.prefix === profile.prefix || child.namespaceURI === profile.namespace);
+        if (!handled) edgeExtensionElements.push(serializer.serializeToString(child));
+      }
+    }
+    model.edges.push(createEdge(source, el.getAttribute('targetRef') || '', {
+      id,
+      type: 'sequenceFlow',
+      name: el.getAttribute('name') || '',
+      condition: condition?.textContent?.trim() || '',
+      isDefault: sourceNode?.defaultFlowId === id,
+      waypoints: edgeDiMap.get(id) || null,
+      properties: { documentation: Array.from(el.children || []).find((child) => child.localName === 'documentation')?.textContent || '', executionListeners: [], extensionAttributes: {}, ...edgeProperties },
+      unknownAttributes: edgeUnknownAttributes,
+      extensionElements: edgeExtensionElements,
+      scopeId,
+    }));
+  }
+  for (const { el, scopeId } of associationEls) {
+    const edgeType = el.localName === 'messageFlow' ? 'messageFlow' : 'association';
+    const properties = {
+      documentation: Array.from(el.children || []).find((child) => child.localName === 'documentation')?.textContent || '',
+      executionListeners: [],
+      extensionAttributes: {},
+      messageRef: edgeType === 'messageFlow' ? (el.getAttribute('messageRef') || '') : '',
+      associationDirection: edgeType === 'association' ? (el.getAttribute('associationDirection') || 'None') : 'None',
+    };
+    const unknownAttributes = [];
+    for (const attr of Array.from(el.attributes || [])) {
+      if (['id', 'name', 'sourceRef', 'targetRef', 'messageRef', 'associationDirection'].includes(attr.localName)) continue;
+      unknownAttributes.push({ name: attr.name, value: attr.value });
+      if (attr.name.includes(':')) properties.extensionAttributes[attr.name] = attr.value;
+    }
+    const extensionElements = [];
+    const ext = Array.from(el.children || []).find((child) => child.localName === 'extensionElements');
+    if (ext && typeof XMLSerializer !== 'undefined') {
+      const serializer = new XMLSerializer();
+      for (const child of Array.from(ext.children || [])) extensionElements.push(serializer.serializeToString(child));
+    }
+    model.edges.push(createEdge(el.getAttribute('sourceRef') || '', el.getAttribute('targetRef') || '', {
+      id: el.getAttribute('id') || `Association_${model.edges.length + 1}`,
+      type: edgeType,
+      name: el.getAttribute('name') || '',
+      waypoints: edgeDiMap.get(el.getAttribute('id')) || null,
+      properties,
+      unknownAttributes,
+      extensionElements,
+      scopeId,
+    }));
+  }
+  applyContainmentOperation(model, { type: 'reconcile', inferOwners: true, normalize: true });
+  return model;
+}
+
+function escapeXml(value = '') {
+  return String(value).replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll("'", '&apos;');
+}
+function cdata(value = '') { return String(value).replaceAll(']]>', ']]]]><![CDATA[>'); }
+function attrsToString(attrs) {
+  return Object.entries(attrs).filter(([, value]) => value !== undefined && value !== null && value !== '')
+    .map(([name, value]) => `${name}="${escapeXml(value)}"`).join(' ');
+}
+
+function eventDefinitionBody(node) {
+  const def = NODE_DEFINITIONS[node.type] || {};
+  const eventType = def.eventDefinition;
+  if (!eventType) return [];
+  const local = EVENT_LOCAL_BY_DEF[eventType];
+  if (!local) return [];
+  const p = node.properties || {};
+  const refAttr = ({ message: 'messageRef', signal: 'signalRef', error: 'errorRef', escalation: 'escalationRef', link: 'name' })[eventType];
+  let attrs = refAttr && p.eventRef ? ` ${refAttr}="${escapeXml(p.eventRef)}"` : '';
+  if (eventType === 'compensate') {
+    if (p.activityRef) attrs += ` activityRef="${escapeXml(p.activityRef)}"`;
+    if (p.waitForCompletion === false) attrs += ' waitForCompletion="false"';
+  }
+  if (eventType === 'timer') {
+    const tag = ({ date: 'timeDate', cycle: 'timeCycle', duration: 'timeDuration' })[p.timerType] || 'timeDuration';
+    return [`      <bpmn:${local}${attrs}>`, `        <bpmn:${tag} xsi:type="bpmn:tFormalExpression"><![CDATA[${cdata(p.timerValue || 'PT1H')}]]></bpmn:${tag}>`, `      </bpmn:${local}>`];
+  }
+  if (eventType === 'conditional') {
+    return [`      <bpmn:${local}${attrs}>`, `        <bpmn:condition xsi:type="bpmn:tFormalExpression"><![CDATA[${cdata(p.condition || '${true}')}]]></bpmn:condition>`, `      </bpmn:${local}>`];
+  }
+  return [`      <bpmn:${local}${attrs} />`];
+}
+
+function activityBody(node, profile) {
+  const p = node.properties || {};
+  const body = [];
+  if (p.documentation) body.push(`      <bpmn:documentation><![CDATA[${cdata(p.documentation)}]]></bpmn:documentation>`);
+  const extensionElements = [...(node.extensionElements || []), ...(profile.nodeExtensionElements?.(node) || [])];
+  if (extensionElements.length) {
+    body.push('      <bpmn:extensionElements>');
+    for (const raw of extensionElements) body.push(`        ${raw}`);
+    body.push('      </bpmn:extensionElements>');
+  }
+  if (node.type === 'scriptTask' && p.script) body.push(`      <bpmn:script><![CDATA[${cdata(p.script)}]]></bpmn:script>`);
+  if (node.type === 'textAnnotation') body.push(`      <bpmn:text><![CDATA[${cdata(p.text || node.name || '')}]]></bpmn:text>`);
+  if (p.loopType === 'standard') {
+    const loopAttrs = attrsToString({ ...(p.testBefore ? { testBefore: 'true' } : {}), ...(p.loopMaximum !== '' && p.loopMaximum != null ? { loopMaximum: p.loopMaximum } : {}) });
+    if (p.loopCondition) {
+      body.push(`      <bpmn:standardLoopCharacteristics${loopAttrs ? ` ${loopAttrs}` : ''}>`);
+      body.push(`        <bpmn:loopCondition xsi:type="bpmn:tFormalExpression"><![CDATA[${cdata(p.loopCondition)}]]></bpmn:loopCondition>`);
+      body.push('      </bpmn:standardLoopCharacteristics>');
+    } else body.push(`      <bpmn:standardLoopCharacteristics${loopAttrs ? ` ${loopAttrs}` : ''} />`);
+  }
+  if (p.loopType === 'parallel' || p.loopType === 'sequential') {
+    const loopAttrs = {
+      isSequential: p.loopType === 'sequential' ? 'true' : 'false',
+      ...(p.collection ? { [`${profile.prefix}:collection`]: p.collection } : {}),
+      ...(p.elementVariable ? { [`${profile.prefix}:elementVariable`]: p.elementVariable } : {}),
+      ...(p.elementIndexVariable ? { [`${profile.prefix}:elementIndexVariable`]: p.elementIndexVariable } : {}),
+    };
+    const hasBody = !!p.loopCardinality || !!p.completionCondition;
+    if (!hasBody) body.push(`      <bpmn:multiInstanceLoopCharacteristics ${attrsToString(loopAttrs)} />`);
+    else {
+      body.push(`      <bpmn:multiInstanceLoopCharacteristics ${attrsToString(loopAttrs)}>`);
+      if (p.loopCardinality) body.push(`        <bpmn:loopCardinality xsi:type="bpmn:tFormalExpression"><![CDATA[${cdata(p.loopCardinality)}]]></bpmn:loopCardinality>`);
+      if (p.completionCondition) body.push(`        <bpmn:completionCondition xsi:type="bpmn:tFormalExpression"><![CDATA[${cdata(p.completionCondition)}]]></bpmn:completionCondition>`);
+      body.push('      </bpmn:multiInstanceLoopCharacteristics>');
+    }
+  }
+  if (node.type === 'adHocSubProcess' && p.adHocCompletionCondition) body.push(`      <bpmn:completionCondition xsi:type="bpmn:tFormalExpression"><![CDATA[${cdata(p.adHocCompletionCondition)}]]></bpmn:completionCondition>`);
+  if (node.type === 'complexGateway' && p.activationCondition) body.push(`      <bpmn:activationCondition xsi:type="bpmn:tFormalExpression"><![CDATA[${cdata(p.activationCondition)}]]></bpmn:activationCondition>`);
+  body.push(...(profile.nodeChildElements?.(node) || []).map((raw) => `      ${raw}`));
+  body.push(...eventDefinitionBody(node));
+  return body;
+}
+
+function nodeTag(node) { return NODE_DEFINITIONS[node.type]?.localName || node.originalLocalName || 'task'; }
+
+function nodeAttributes(node, profile, model, defaultBySource) {
+  const p = node.properties || {};
+  const common = node.type === 'textAnnotation'
+    ? { id: node.id }
+    : { id: node.id, name: node.name };
+  if (defaultBySource.has(node.id)) common.default = defaultBySource.get(node.id);
+  if (node.type === 'scriptTask' && p.scriptFormat) common.scriptFormat = p.scriptFormat;
+  if (node.type === 'callActivity' && p.calledElement) common.calledElement = p.calledElement;
+  if (['sendTask', 'receiveTask'].includes(node.type)) {
+    if (p.messageRef) common.messageRef = p.messageRef;
+    if (p.operationRef) common.operationRef = p.operationRef;
+    if (node.type === 'receiveTask' && p.instantiate) common.instantiate = 'true';
+  }
+  const eventDef = NODE_DEFINITIONS[node.type] || {};
+  if ((eventDef.eventStage === 'start' || (eventDef.eventStage === 'intermediate' && eventDef.eventRole === 'catch')) && ['message', 'signal'].includes(eventDef.eventDefinition) && p.parallelMultiple) common.parallelMultiple = 'true';
+  if (node.type === 'textAnnotation' && p.textFormat && p.textFormat !== 'text/plain') common.textFormat = p.textFormat;
+  if ((NODE_DEFINITIONS[node.type]?.kind || '') === 'gateway' && p.gatewayDirection && p.gatewayDirection !== 'Unspecified') common.gatewayDirection = p.gatewayDirection;
+  if (node.type === 'eventBasedGateway') {
+    if (p.instantiate) common.instantiate = 'true';
+    if (p.eventGatewayType && p.eventGatewayType !== 'Exclusive') common.eventGatewayType = p.eventGatewayType;
+  }
+  if (node.type === 'adHocSubProcess') {
+    if (p.ordering) common.ordering = p.ordering;
+    if (p.cancelRemainingInstances === false) common.cancelRemainingInstances = 'false';
+  }
+  if (NODE_DEFINITIONS[node.type]?.kind === 'boundary') {
+    if (p.attachedToRef) common.attachedToRef = p.attachedToRef;
+    if (p.cancelActivity === false) common.cancelActivity = 'false';
+  }
+  if (node.type === 'eventSubProcess') common.triggeredByEvent = 'true';
+  if (p.isForCompensation) common.isForCompensation = 'true';
+  if (node.type === 'dataObjectReference') common.dataObjectRef = p.dataObjectRef || `${node.id}_Object`;
+  if (node.type === 'dataStoreReference') common.dataStoreRef = p.dataStoreRef || `${node.id}_Store`;
+  const unknownAttrs = Object.fromEntries((node.unknownAttributes || []).map((a) => [a.name, a.value]));
+  return attrsToString({ ...unknownAttrs, ...common, ...profile.nodeAttributes(node) });
+}
+
+function nodesInsideLane(model, lane) {
+  const explicit = lane.properties?.flowNodeRefs;
+  if (Array.isArray(explicit)) return explicit;
+  return model.nodes.filter((node) => {
+    if (node.id === lane.id || ['lane', 'participant', 'group'].includes(node.type)) return false;
+    const cx = node.x + node.width / 2;
+    const cy = node.y + node.height / 2;
+    return cx >= lane.x && cx <= lane.x + lane.width && cy >= lane.y && cy <= lane.y + lane.height;
+  }).map((node) => node.id);
+}
+
+export function exportBpmn(model, engineOverride) {
+  const engine = engineOverride || model.engine || 'flowable';
+  const profile = getProfile(engine);
+  const participants = model.nodes.filter((node) => node.type === 'participant');
+  const participantOrder = new Map(participants.map((participant, index) => [participant.id, index]));
+  const lanes = model.nodes.filter((node) => node.type === 'lane').sort((a, b) => {
+    const aOwner = participantOrder.has(a.containerId) ? participantOrder.get(a.containerId) : Number.MAX_SAFE_INTEGER;
+    const bOwner = participantOrder.has(b.containerId) ? participantOrder.get(b.containerId) : Number.MAX_SAFE_INTEGER;
+    return aOwner - bOwner || a.y - b.y || a.x - b.x || a.id.localeCompare(b.id);
+  });
+  const groups = model.nodes.filter((node) => node.type === 'group');
+  const dataObjects = model.nodes.filter((node) => node.type === 'dataObjectReference');
+  const dataStores = model.nodes.filter((node) => node.type === 'dataStoreReference');
+  const processNodes = model.nodes.filter((node) => !['participant', 'lane'].includes(node.type));
+  const sequenceFlows = model.edges.filter((edge) => (edge.type || 'sequenceFlow') === 'sequenceFlow');
+  const associations = model.edges.filter((edge) => edge.type === 'association');
+  const messageFlows = model.edges.filter((edge) => edge.type === 'messageFlow');
+  const hasCollaboration = participants.length > 0 || messageFlows.length > 0;
+  const planeElement = hasCollaboration ? `Collaboration_${model.id}` : model.id;
+
+  const extraNs = Object.entries(model.namespaceDeclarations || {}).map(([name, value]) => `${name}="${escapeXml(value)}"`).join('\n  ');
+  const lines = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    `<bpmn:definitions xmlns:bpmn="${NS.bpmn}"`,
+    `  xmlns:bpmndi="${NS.bpmndi}"`,
+    `  xmlns:dc="${NS.dc}"`,
+    `  xmlns:di="${NS.di}"`,
+    `  xmlns:xsi="${NS.xsi}"`,
+    `  xmlns:${profile.prefix}="${profile.namespace}"`,
+    ...(extraNs ? [`  ${extraNs}`] : []),
+    `  id="Definitions_${escapeXml(model.id)}"`,
+    `  targetNamespace="${escapeXml(model.targetNamespace || 'urn:bpmn-nova:process')}">`,
+  ];
+
+  for (const message of model.resources?.messages || []) lines.push(`  <bpmn:message ${attrsToString({ id: message.id, name: message.name })} />`);
+  for (const signal of model.resources?.signals || []) lines.push(`  <bpmn:signal ${attrsToString({ id: signal.id, name: signal.name })} />`);
+  for (const error of model.resources?.errors || []) lines.push(`  <bpmn:error ${attrsToString({ id: error.id, name: error.name, errorCode: error.errorCode })} />`);
+  for (const escalation of model.resources?.escalations || []) lines.push(`  <bpmn:escalation ${attrsToString({ id: escalation.id, name: escalation.name, escalationCode: escalation.escalationCode })} />`);
+
+  for (const node of dataStores) lines.push(`  <bpmn:dataStore id="${escapeXml(node.properties?.dataStoreRef || `${node.id}_Store`)}" name="${escapeXml(node.name)}" />`);
+  for (const group of groups) {
+    lines.push(`  <bpmn:category id="Category_${escapeXml(group.id)}">`);
+    lines.push(`    <bpmn:categoryValue id="CategoryValue_${escapeXml(group.id)}" value="${escapeXml(group.properties?.categoryValue || group.name || '分组')}" />`);
+    lines.push('  </bpmn:category>');
+  }
+
+  const processAttrs = attrsToString({ id: model.id, name: model.name || model.id, isExecutable: model.isExecutable !== false ? 'true' : 'false', ...(profile.processAttributes?.(model) || {}) });
+  lines.push(`  <bpmn:process ${processAttrs}>`);
+  if (model.properties?.documentation) lines.push(`    <bpmn:documentation><![CDATA[${cdata(model.properties.documentation)}]]></bpmn:documentation>`);
+  const processExtensions = [...(model.extensionElements || []), ...(profile.processExtensionElements?.(model) || [])];
+  if (processExtensions.length) {
+    lines.push('    <bpmn:extensionElements>');
+    for (const raw of processExtensions) lines.push(`      ${raw}`);
+    lines.push('    </bpmn:extensionElements>');
+  }
+
+  if (lanes.length) {
+    lines.push(`    <bpmn:laneSet id="LaneSet_${escapeXml(model.id)}">`);
+    for (const lane of lanes) {
+      lines.push(`      <bpmn:lane id="${escapeXml(lane.id)}" name="${escapeXml(lane.name)}">`);
+      for (const ref of nodesInsideLane(model, lane)) lines.push(`        <bpmn:flowNodeRef>${escapeXml(ref)}</bpmn:flowNodeRef>`);
+      lines.push('      </bpmn:lane>');
+    }
+    lines.push('    </bpmn:laneSet>');
+  }
+
+  for (const node of dataObjects) lines.push(`    <bpmn:dataObject id="${escapeXml(node.properties?.dataObjectRef || `${node.id}_Object`)}" name="${escapeXml(node.name)}" />`);
+
+  const defaultBySource = new Map(sequenceFlows.filter((edge) => edge.isDefault).map((edge) => [edge.source, edge.id]));
+  const serializeScope = (scopeId, indent = '    ') => {
+    const output = [];
+    const bodyIndent = `${indent}  `;
+    const reindentBody = (body) => body.map((line) => line.replace(/^      /, bodyIndent));
+    for (const node of processNodes.filter((item) => elementScopeId(model, item) === scopeId)) {
+      const tag = nodeTag(node);
+      const attrs = nodeAttributes(node, profile, model, defaultBySource);
+      if (node.type === 'group') {
+        output.push(`${indent}<bpmn:group ${attrsToString({ id: node.id, categoryValueRef: `CategoryValue_${node.id}` })} />`);
+        continue;
+      }
+      const body = reindentBody(activityBody(node, profile));
+      const nested = isEmbeddedSubProcess(node) ? serializeScope(node.id, bodyIndent) : [];
+      if (body.length || nested.length) {
+        output.push(`${indent}<bpmn:${tag} ${attrs}>`, ...body, ...nested, `${indent}</bpmn:${tag}>`);
+      } else output.push(`${indent}<bpmn:${tag} ${attrs} />`);
+    }
+
+    for (const edge of sequenceFlows.filter((item) => elementScopeId(model, item) === scopeId)) {
+      const unknownAttrs = Object.fromEntries((edge.unknownAttributes || []).map((a) => [a.name, a.value]));
+      const attrs = attrsToString({ ...unknownAttrs, ...(edge.properties?.extensionAttributes || {}), id: edge.id, name: edge.name, sourceRef: edge.source, targetRef: edge.target });
+      const edgeExtensions = [...(edge.extensionElements || []), ...(profile.edgeExtensionElements?.(edge) || [])];
+      if (edge.condition || edgeExtensions.length || edge.properties?.documentation) {
+        output.push(`${indent}<bpmn:sequenceFlow ${attrs}>`);
+        if (edge.properties?.documentation) output.push(`${bodyIndent}<bpmn:documentation><![CDATA[${cdata(edge.properties.documentation)}]]></bpmn:documentation>`);
+        if (edge.condition) output.push(`${bodyIndent}<bpmn:conditionExpression xsi:type="bpmn:tFormalExpression"><![CDATA[${cdata(edge.condition)}]]></bpmn:conditionExpression>`);
+        if (edgeExtensions.length) {
+          output.push(`${bodyIndent}<bpmn:extensionElements>`);
+          for (const raw of edgeExtensions) output.push(`${bodyIndent}  ${raw}`);
+          output.push(`${bodyIndent}</bpmn:extensionElements>`);
+        }
+        output.push(`${indent}</bpmn:sequenceFlow>`);
+      } else output.push(`${indent}<bpmn:sequenceFlow ${attrs} />`);
+    }
+
+    for (const edge of associations.filter((item) => elementScopeId(model, item) === scopeId)) {
+      const unknownAttrs = Object.fromEntries((edge.unknownAttributes || []).map((item) => [item.name, item.value]));
+      const attrs = attrsToString({ ...unknownAttrs, ...(edge.properties?.extensionAttributes || {}), id: edge.id, sourceRef: edge.source, targetRef: edge.target, associationDirection: edge.properties?.associationDirection && edge.properties.associationDirection !== 'None' ? edge.properties.associationDirection : '' });
+      const body = [];
+      if (edge.properties?.documentation) body.push(`${bodyIndent}<bpmn:documentation><![CDATA[${cdata(edge.properties.documentation)}]]></bpmn:documentation>`);
+      if ((edge.extensionElements || []).length) {
+        body.push(`${bodyIndent}<bpmn:extensionElements>`);
+        for (const raw of edge.extensionElements || []) body.push(`${bodyIndent}  ${raw}`);
+        body.push(`${bodyIndent}</bpmn:extensionElements>`);
+      }
+      if (body.length) output.push(`${indent}<bpmn:association ${attrs}>`, ...body, `${indent}</bpmn:association>`);
+      else output.push(`${indent}<bpmn:association ${attrs} />`);
+    }
+    return output;
+  };
+  lines.push(...serializeScope(model.id));
+  lines.push('  </bpmn:process>');
+
+  if (hasCollaboration) {
+    lines.push(`  <bpmn:collaboration id="Collaboration_${escapeXml(model.id)}">`);
+    if (participants.length) {
+      for (const participant of participants) lines.push(`    <bpmn:participant ${attrsToString({ id: participant.id, name: participant.name, processRef: participant.properties?.processRef || model.id })} />`);
+    } else {
+      lines.push(`    <bpmn:participant id="Participant_${escapeXml(model.id)}" name="${escapeXml(model.name)}" processRef="${escapeXml(model.id)}" />`);
+    }
+    for (const edge of messageFlows) {
+      const unknownAttrs = Object.fromEntries((edge.unknownAttributes || []).map((item) => [item.name, item.value]));
+      const attrs = attrsToString({ ...unknownAttrs, ...(edge.properties?.extensionAttributes || {}), id: edge.id, name: edge.name, sourceRef: edge.source, targetRef: edge.target, messageRef: edge.properties?.messageRef });
+      const body = [];
+      if (edge.properties?.documentation) body.push(`      <bpmn:documentation><![CDATA[${cdata(edge.properties.documentation)}]]></bpmn:documentation>`);
+      if ((edge.extensionElements || []).length) {
+        body.push('      <bpmn:extensionElements>');
+        for (const raw of edge.extensionElements || []) body.push(`        ${raw}`);
+        body.push('      </bpmn:extensionElements>');
+      }
+      if (body.length) {
+        lines.push(`    <bpmn:messageFlow ${attrs}>`);
+        lines.push(...body);
+        lines.push('    </bpmn:messageFlow>');
+      } else lines.push(`    <bpmn:messageFlow ${attrs} />`);
+    }
+    lines.push('  </bpmn:collaboration>');
+  }
+
+  lines.push(`  <bpmndi:BPMNDiagram id="BPMNDiagram_${escapeXml(model.id)}">`);
+  lines.push(`    <bpmndi:BPMNPlane id="BPMNPlane_${escapeXml(model.id)}" bpmnElement="${escapeXml(planeElement)}">`);
+  for (const node of model.nodes) {
+    const def = NODE_DEFINITIONS[node.type] || NODE_DEFINITIONS.generic;
+    const extra = ['container'].includes(def.kind) ? ' isExpanded="false"' : '';
+    lines.push(`      <bpmndi:BPMNShape id="${escapeXml(node.id)}_di" bpmnElement="${escapeXml(node.id)}"${extra}>`);
+    lines.push(`        <dc:Bounds x="${Math.round(node.x)}" y="${Math.round(node.y)}" width="${Math.round(node.width)}" height="${Math.round(node.height)}" />`);
+    lines.push('      </bpmndi:BPMNShape>');
+  }
+  for (const edge of model.edges) {
+    lines.push(`      <bpmndi:BPMNEdge id="${escapeXml(edge.id)}_di" bpmnElement="${escapeXml(edge.id)}">`);
+    for (const point of edgeWaypoints(model, edge)) lines.push(`        <di:waypoint x="${Math.round(point.x)}" y="${Math.round(point.y)}" />`);
+    lines.push('      </bpmndi:BPMNEdge>');
+  }
+  lines.push('    </bpmndi:BPMNPlane>');
+  lines.push('  </bpmndi:BPMNDiagram>');
+  lines.push('</bpmn:definitions>');
+  return lines.join('\n');
+}