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

package/dist/modules/core/model.js

@@ -0,0 +1,287 @@
+export const NODE_DEFINITIONS = {
+  // Events — start
+  startEvent: { bpmnType: 'bpmn:StartEvent', localName: 'startEvent', label: '开始事件', icon: '', kind: 'event', eventStage: 'start', eventDefinition: null, width: 56, height: 56, palette: 'startEvents' },
+  messageStartEvent: { bpmnType: 'bpmn:StartEvent', localName: 'startEvent', label: '消息开始', icon: '✉', kind: 'event', eventStage: 'start', eventDefinition: 'message', width: 56, height: 56, palette: 'startEvents' },
+  timerStartEvent: { bpmnType: 'bpmn:StartEvent', localName: 'startEvent', label: '定时开始', icon: '◷', kind: 'event', eventStage: 'start', eventDefinition: 'timer', width: 56, height: 56, palette: 'startEvents' },
+  conditionalStartEvent: { bpmnType: 'bpmn:StartEvent', localName: 'startEvent', label: '条件开始', icon: '≡', kind: 'event', eventStage: 'start', eventDefinition: 'conditional', width: 56, height: 56, palette: 'startEvents' },
+  signalStartEvent: { bpmnType: 'bpmn:StartEvent', localName: 'startEvent', label: '信号开始', icon: '△', kind: 'event', eventStage: 'start', eventDefinition: 'signal', width: 56, height: 56, palette: 'startEvents' },
+  errorStartEvent: { bpmnType: 'bpmn:StartEvent', localName: 'startEvent', label: '错误开始', icon: '⚡', kind: 'event', eventStage: 'start', eventDefinition: 'error', width: 56, height: 56, palette: 'startEvents' },
+  escalationStartEvent: { bpmnType: 'bpmn:StartEvent', localName: 'startEvent', label: '升级开始', icon: '▲', kind: 'event', eventStage: 'start', eventDefinition: 'escalation', width: 56, height: 56, palette: 'startEvents' },
+  compensationStartEvent: { bpmnType: 'bpmn:StartEvent', localName: 'startEvent', label: '补偿开始', icon: '≪', kind: 'event', eventStage: 'start', eventDefinition: 'compensate', width: 56, height: 56, palette: 'startEvents' },
+
+  // Events — intermediate catch / throw
+  intermediateCatchEvent: { bpmnType: 'bpmn:IntermediateCatchEvent', localName: 'intermediateCatchEvent', label: '中间捕获事件', icon: '', kind: 'event', eventStage: 'intermediate', eventRole: 'catch', eventDefinition: null, width: 56, height: 56, palette: 'intermediateEvents' },
+  messageIntermediateCatchEvent: { bpmnType: 'bpmn:IntermediateCatchEvent', localName: 'intermediateCatchEvent', label: '消息捕获', icon: '✉', kind: 'event', eventStage: 'intermediate', eventRole: 'catch', eventDefinition: 'message', width: 56, height: 56, palette: 'intermediateEvents' },
+  timerIntermediateCatchEvent: { bpmnType: 'bpmn:IntermediateCatchEvent', localName: 'intermediateCatchEvent', label: '定时捕获', icon: '◷', kind: 'event', eventStage: 'intermediate', eventRole: 'catch', eventDefinition: 'timer', width: 56, height: 56, palette: 'intermediateEvents' },
+  conditionalIntermediateCatchEvent: { bpmnType: 'bpmn:IntermediateCatchEvent', localName: 'intermediateCatchEvent', label: '条件捕获', icon: '≡', kind: 'event', eventStage: 'intermediate', eventRole: 'catch', eventDefinition: 'conditional', width: 56, height: 56, palette: 'intermediateEvents' },
+  signalIntermediateCatchEvent: { bpmnType: 'bpmn:IntermediateCatchEvent', localName: 'intermediateCatchEvent', label: '信号捕获', icon: '△', kind: 'event', eventStage: 'intermediate', eventRole: 'catch', eventDefinition: 'signal', width: 56, height: 56, palette: 'intermediateEvents' },
+  linkIntermediateCatchEvent: { bpmnType: 'bpmn:IntermediateCatchEvent', localName: 'intermediateCatchEvent', label: '链接捕获', icon: '↙', kind: 'event', eventStage: 'intermediate', eventRole: 'catch', eventDefinition: 'link', width: 56, height: 56, palette: 'intermediateEvents' },
+  intermediateThrowEvent: { bpmnType: 'bpmn:IntermediateThrowEvent', localName: 'intermediateThrowEvent', label: '中间抛出事件', icon: '', kind: 'event', eventStage: 'intermediate', eventRole: 'throw', eventDefinition: null, width: 56, height: 56, palette: 'intermediateEvents' },
+  messageIntermediateThrowEvent: { bpmnType: 'bpmn:IntermediateThrowEvent', localName: 'intermediateThrowEvent', label: '消息抛出', icon: '✉', kind: 'event', eventStage: 'intermediate', eventRole: 'throw', eventDefinition: 'message', width: 56, height: 56, palette: 'intermediateEvents' },
+  escalationIntermediateThrowEvent: { bpmnType: 'bpmn:IntermediateThrowEvent', localName: 'intermediateThrowEvent', label: '升级抛出', icon: '▲', kind: 'event', eventStage: 'intermediate', eventRole: 'throw', eventDefinition: 'escalation', width: 56, height: 56, palette: 'intermediateEvents' },
+  signalIntermediateThrowEvent: { bpmnType: 'bpmn:IntermediateThrowEvent', localName: 'intermediateThrowEvent', label: '信号抛出', icon: '△', kind: 'event', eventStage: 'intermediate', eventRole: 'throw', eventDefinition: 'signal', width: 56, height: 56, palette: 'intermediateEvents' },
+  linkIntermediateThrowEvent: { bpmnType: 'bpmn:IntermediateThrowEvent', localName: 'intermediateThrowEvent', label: '链接抛出', icon: '↗', kind: 'event', eventStage: 'intermediate', eventRole: 'throw', eventDefinition: 'link', width: 56, height: 56, palette: 'intermediateEvents' },
+  compensationIntermediateThrowEvent: { bpmnType: 'bpmn:IntermediateThrowEvent', localName: 'intermediateThrowEvent', label: '补偿抛出', icon: '≪', kind: 'event', eventStage: 'intermediate', eventRole: 'throw', eventDefinition: 'compensate', width: 56, height: 56, palette: 'intermediateEvents' },
+
+  // Events — boundary
+  timerBoundaryEvent: { bpmnType: 'bpmn:BoundaryEvent', localName: 'boundaryEvent', label: '定时边界事件', icon: '◷', kind: 'boundary', eventStage: 'boundary', eventRole: 'catch', eventDefinition: 'timer', width: 46, height: 46, palette: 'boundaryEvents' },
+  messageBoundaryEvent: { bpmnType: 'bpmn:BoundaryEvent', localName: 'boundaryEvent', label: '消息边界事件', icon: '✉', kind: 'boundary', eventStage: 'boundary', eventRole: 'catch', eventDefinition: 'message', width: 46, height: 46, palette: 'boundaryEvents' },
+  errorBoundaryEvent: { bpmnType: 'bpmn:BoundaryEvent', localName: 'boundaryEvent', label: '错误边界事件', icon: '⚡', kind: 'boundary', eventStage: 'boundary', eventRole: 'catch', eventDefinition: 'error', width: 46, height: 46, palette: 'boundaryEvents' },
+  escalationBoundaryEvent: { bpmnType: 'bpmn:BoundaryEvent', localName: 'boundaryEvent', label: '升级边界事件', icon: '▲', kind: 'boundary', eventStage: 'boundary', eventRole: 'catch', eventDefinition: 'escalation', width: 46, height: 46, palette: 'boundaryEvents' },
+  signalBoundaryEvent: { bpmnType: 'bpmn:BoundaryEvent', localName: 'boundaryEvent', label: '信号边界事件', icon: '△', kind: 'boundary', eventStage: 'boundary', eventRole: 'catch', eventDefinition: 'signal', width: 46, height: 46, palette: 'boundaryEvents' },
+  conditionalBoundaryEvent: { bpmnType: 'bpmn:BoundaryEvent', localName: 'boundaryEvent', label: '条件边界事件', icon: '≡', kind: 'boundary', eventStage: 'boundary', eventRole: 'catch', eventDefinition: 'conditional', width: 46, height: 46, palette: 'boundaryEvents' },
+  compensationBoundaryEvent: { bpmnType: 'bpmn:BoundaryEvent', localName: 'boundaryEvent', label: '补偿边界事件', icon: '≪', kind: 'boundary', eventStage: 'boundary', eventRole: 'catch', eventDefinition: 'compensate', width: 46, height: 46, palette: 'boundaryEvents' },
+
+  // Events — end
+  endEvent: { bpmnType: 'bpmn:EndEvent', localName: 'endEvent', label: '结束事件', icon: '', kind: 'event', eventStage: 'end', eventDefinition: null, width: 56, height: 56, palette: 'endEvents' },
+  messageEndEvent: { bpmnType: 'bpmn:EndEvent', localName: 'endEvent', label: '消息结束', icon: '✉', kind: 'event', eventStage: 'end', eventDefinition: 'message', width: 56, height: 56, palette: 'endEvents' },
+  errorEndEvent: { bpmnType: 'bpmn:EndEvent', localName: 'endEvent', label: '错误结束', icon: '⚡', kind: 'event', eventStage: 'end', eventDefinition: 'error', width: 56, height: 56, palette: 'endEvents' },
+  escalationEndEvent: { bpmnType: 'bpmn:EndEvent', localName: 'endEvent', label: '升级结束', icon: '▲', kind: 'event', eventStage: 'end', eventDefinition: 'escalation', width: 56, height: 56, palette: 'endEvents' },
+  cancelEndEvent: { bpmnType: 'bpmn:EndEvent', localName: 'endEvent', label: '取消结束', icon: '×', kind: 'event', eventStage: 'end', eventDefinition: 'cancel', width: 56, height: 56, palette: 'endEvents' },
+  compensationEndEvent: { bpmnType: 'bpmn:EndEvent', localName: 'endEvent', label: '补偿结束', icon: '≪', kind: 'event', eventStage: 'end', eventDefinition: 'compensate', width: 56, height: 56, palette: 'endEvents' },
+  signalEndEvent: { bpmnType: 'bpmn:EndEvent', localName: 'endEvent', label: '信号结束', icon: '△', kind: 'event', eventStage: 'end', eventDefinition: 'signal', width: 56, height: 56, palette: 'endEvents' },
+  terminateEndEvent: { bpmnType: 'bpmn:EndEvent', localName: 'endEvent', label: '终止结束', icon: '●', kind: 'event', eventStage: 'end', eventDefinition: 'terminate', width: 56, height: 56, palette: 'endEvents' },
+
+  // Activities
+  task: { bpmnType: 'bpmn:Task', localName: 'task', label: '任务', icon: '□', kind: 'task', width: 216, height: 72, palette: 'tasks' },
+  userTask: { bpmnType: 'bpmn:UserTask', localName: 'userTask', label: '用户任务', icon: '♙', kind: 'task', width: 216, height: 72, palette: 'tasks' },
+  manualTask: { bpmnType: 'bpmn:ManualTask', localName: 'manualTask', label: '手工任务', icon: '✋', kind: 'task', width: 216, height: 72, palette: 'tasks' },
+  serviceTask: { bpmnType: 'bpmn:ServiceTask', localName: 'serviceTask', label: '服务任务', icon: '⚙', kind: 'task', width: 216, height: 72, palette: 'tasks' },
+  scriptTask: { bpmnType: 'bpmn:ScriptTask', localName: 'scriptTask', label: '脚本任务', icon: '</>', kind: 'task', width: 216, height: 72, palette: 'tasks' },
+  businessRuleTask: { bpmnType: 'bpmn:BusinessRuleTask', localName: 'businessRuleTask', label: '业务规则任务', icon: '▦', kind: 'task', width: 216, height: 72, palette: 'tasks' },
+  sendTask: { bpmnType: 'bpmn:SendTask', localName: 'sendTask', label: '发送任务', icon: '✉', kind: 'task', width: 216, height: 72, palette: 'tasks' },
+  receiveTask: { bpmnType: 'bpmn:ReceiveTask', localName: 'receiveTask', label: '接收任务', icon: '✉', kind: 'task', width: 216, height: 72, palette: 'tasks' },
+  callActivity: { bpmnType: 'bpmn:CallActivity', localName: 'callActivity', label: '调用活动', icon: '↗', kind: 'task', activityKind: 'call', width: 216, height: 72, palette: 'activities' },
+  subProcess: { bpmnType: 'bpmn:SubProcess', localName: 'subProcess', label: '子流程', icon: '＋', kind: 'container', activityKind: 'subProcess', width: 272, height: 126, palette: 'activities' },
+  eventSubProcess: { bpmnType: 'bpmn:SubProcess', localName: 'subProcess', label: '事件子流程', icon: '◉', kind: 'container', activityKind: 'eventSubProcess', width: 272, height: 126, palette: 'activities' },
+  transaction: { bpmnType: 'bpmn:Transaction', localName: 'transaction', label: '事务子流程', icon: '▣', kind: 'container', activityKind: 'transaction', width: 272, height: 126, palette: 'activities' },
+  adHocSubProcess: { bpmnType: 'bpmn:AdHocSubProcess', localName: 'adHocSubProcess', label: 'Ad-hoc 子流程', icon: '~', kind: 'container', activityKind: 'adHoc', width: 272, height: 126, palette: 'activities' },
+
+  // Gateways
+  exclusiveGateway: { bpmnType: 'bpmn:ExclusiveGateway', localName: 'exclusiveGateway', label: '排他网关', icon: '×', kind: 'gateway', width: 72, height: 72, palette: 'gateways' },
+  parallelGateway: { bpmnType: 'bpmn:ParallelGateway', localName: 'parallelGateway', label: '并行网关', icon: '+', kind: 'gateway', width: 72, height: 72, palette: 'gateways' },
+  inclusiveGateway: { bpmnType: 'bpmn:InclusiveGateway', localName: 'inclusiveGateway', label: '包容网关', icon: '○', kind: 'gateway', width: 72, height: 72, palette: 'gateways' },
+  eventBasedGateway: { bpmnType: 'bpmn:EventBasedGateway', localName: 'eventBasedGateway', label: '事件网关', icon: '◉', kind: 'gateway', width: 72, height: 72, palette: 'gateways' },
+  complexGateway: { bpmnType: 'bpmn:ComplexGateway', localName: 'complexGateway', label: '复杂网关', icon: '✣', kind: 'gateway', width: 72, height: 72, palette: 'gateways' },
+
+  // Data / artifacts / collaboration
+  dataObjectReference: { bpmnType: 'bpmn:DataObjectReference', localName: 'dataObjectReference', label: '数据对象', icon: '▤', kind: 'data', width: 72, height: 88, palette: 'data' },
+  dataStoreReference: { bpmnType: 'bpmn:DataStoreReference', localName: 'dataStoreReference', label: '数据存储', icon: '⌁', kind: 'dataStore', width: 78, height: 78, palette: 'data' },
+  textAnnotation: { bpmnType: 'bpmn:TextAnnotation', localName: 'textAnnotation', label: '文本注释', icon: 'T', kind: 'annotation', width: 180, height: 88, palette: 'artifacts' },
+  group: { bpmnType: 'bpmn:Group', localName: 'group', label: '分组', icon: '▦', kind: 'group', width: 300, height: 180, palette: 'artifacts' },
+  participant: { bpmnType: 'bpmn:Participant', localName: 'participant', label: '参与者 / Pool', icon: '▥', kind: 'participant', width: 760, height: 240, palette: 'collaboration' },
+  lane: { bpmnType: 'bpmn:Lane', localName: 'lane', label: '泳道 Lane', icon: '═', kind: 'lane', width: 700, height: 140, palette: 'collaboration' },
+
+  generic: { bpmnType: 'bpmn:Task', localName: 'task', label: 'BPMN 节点', icon: '◆', kind: 'task', width: 216, height: 72 },
+};
+
+export const PALETTE_GROUPS = [
+  { id: 'favorites', label: '常用', types: ['startEvent', 'userTask', 'serviceTask', 'exclusiveGateway', 'parallelGateway', 'subProcess', 'endEvent'] },
+  { id: 'startEvents', label: '开始事件', types: Object.keys(NODE_DEFINITIONS).filter((type) => NODE_DEFINITIONS[type]?.palette === 'startEvents') },
+  { id: 'intermediateEvents', label: '中间事件', types: Object.keys(NODE_DEFINITIONS).filter((type) => NODE_DEFINITIONS[type]?.palette === 'intermediateEvents') },
+  { id: 'boundaryEvents', label: '边界事件', types: Object.keys(NODE_DEFINITIONS).filter((type) => NODE_DEFINITIONS[type]?.palette === 'boundaryEvents') },
+  { id: 'endEvents', label: '结束事件', types: Object.keys(NODE_DEFINITIONS).filter((type) => NODE_DEFINITIONS[type]?.palette === 'endEvents') },
+  { id: 'tasks', label: '任务', types: Object.keys(NODE_DEFINITIONS).filter((type) => NODE_DEFINITIONS[type]?.palette === 'tasks') },
+  { id: 'activities', label: '活动 / 子流程', types: Object.keys(NODE_DEFINITIONS).filter((type) => NODE_DEFINITIONS[type]?.palette === 'activities') },
+  { id: 'gateways', label: '网关', types: Object.keys(NODE_DEFINITIONS).filter((type) => NODE_DEFINITIONS[type]?.palette === 'gateways') },
+  { id: 'data', label: '数据', types: Object.keys(NODE_DEFINITIONS).filter((type) => NODE_DEFINITIONS[type]?.palette === 'data') },
+  { id: 'artifacts', label: '注释 / 分组', types: Object.keys(NODE_DEFINITIONS).filter((type) => NODE_DEFINITIONS[type]?.palette === 'artifacts') },
+  { id: 'collaboration', label: '协作 / 泳道', types: Object.keys(NODE_DEFINITIONS).filter((type) => NODE_DEFINITIONS[type]?.palette === 'collaboration') },
+];
+
+export const EDGE_DEFINITIONS = {
+  sequenceFlow: { bpmnType: 'bpmn:SequenceFlow', label: '顺序流' },
+  messageFlow: { bpmnType: 'bpmn:MessageFlow', label: '消息流' },
+  association: { bpmnType: 'bpmn:Association', label: '关联' },
+};
+
+let idSeed = 0;
+export function uid(prefix = 'Element') {
+  idSeed += 1;
+  return `${prefix}_${Date.now().toString(36)}_${idSeed.toString(36)}`;
+}
+
+function defaultNodeProperties(type, def, overrides = {}) {
+  const props = {
+    documentation: '',
+    loopType: 'none',
+    isForCompensation: false,
+    async: false,
+    exclusive: true,
+    asyncLeave: false,
+    failedJobRetryTimeCycle: '',
+    executionListeners: [],
+    loopCondition: '',
+    loopMaximum: '',
+    testBefore: false,
+    extensionAttributes: {},
+  };
+
+  if (type === 'userTask') Object.assign(props, { assignee: '', owner: '', candidateUsers: '', candidateGroups: '', formKey: '', dueDate: '', priority: '', category: '', skipExpression: '', taskListeners: [] });
+  if (['serviceTask', 'sendTask', 'businessRuleTask'].includes(type)) Object.assign(props, { implementationType: 'class', implementation: '', fields: [], resultVariable: '' });
+  if (type === 'sendTask') Object.assign(props, { messageRef: '', operationRef: '' });
+  if (type === 'receiveTask') Object.assign(props, { messageRef: '', operationRef: '', instantiate: false });
+  if (type === 'scriptTask') Object.assign(props, { scriptFormat: 'javascript', script: '', resultVariable: '' });
+  if (type === 'callActivity') Object.assign(props, { calledElement: '', businessKey: '', inheritBusinessKey: false, inheritVariables: false, sameDeployment: false, processInstanceName: '', inParameters: [], outParameters: [] });
+  if (def.eventDefinition === 'timer') Object.assign(props, { timerType: 'duration', timerValue: 'PT1H' });
+  if (def.eventDefinition === 'conditional') Object.assign(props, { condition: '${approved == true}' });
+  if (['message', 'signal', 'error', 'escalation', 'link'].includes(def.eventDefinition)) Object.assign(props, { eventRef: '' });
+  if ((def.eventStage === 'start' || (def.eventStage === 'intermediate' && def.eventRole === 'catch')) && ['message', 'signal'].includes(def.eventDefinition)) Object.assign(props, { parallelMultiple: false });
+  if (def.kind === 'boundary') Object.assign(props, { attachedToRef: '', cancelActivity: true });
+  if (type === 'eventSubProcess') Object.assign(props, { triggeredByEvent: true });
+  if (type === 'adHocSubProcess') Object.assign(props, { ordering: 'Parallel', adHocCompletionCondition: '', cancelRemainingInstances: true });
+  if (['exclusiveGateway', 'parallelGateway', 'inclusiveGateway', 'eventBasedGateway', 'complexGateway'].includes(type)) Object.assign(props, { gatewayDirection: 'Unspecified' });
+  if (type === 'eventBasedGateway') Object.assign(props, { instantiate: false, eventGatewayType: 'Exclusive' });
+  if (type === 'complexGateway') Object.assign(props, { activationCondition: '' });
+  if (def.eventDefinition === 'compensate') Object.assign(props, { activityRef: '', waitForCompletion: true });
+  if (type === 'textAnnotation') Object.assign(props, { text: '说明文字', textFormat: 'text/plain' });
+  if (type === 'dataObjectReference') Object.assign(props, { dataObjectRef: '', dataState: '' });
+  if (type === 'dataStoreReference') Object.assign(props, { dataStoreRef: '', dataState: '' });
+  if (type === 'group') Object.assign(props, { categoryValue: '' });
+  if (type === 'participant') Object.assign(props, { processRef: '', swimlaneLabelPlacement: 'side' });
+  if (type === 'lane') Object.assign(props, { flowNodeRefs: [], swimlaneLabelPlacement: 'side' });
+
+  return { ...props, ...(overrides.properties || {}) };
+}
+
+export function createNode(type, x = 100, y = 100, overrides = {}) {
+  const def = NODE_DEFINITIONS[type] || NODE_DEFINITIONS.generic;
+  const base = {
+    id: uid(type),
+    type,
+    bpmnType: def.bpmnType,
+    name: overrides.name || def.label,
+    x,
+    y,
+    width: def.width,
+    height: def.height,
+    properties: defaultNodeProperties(type, def, overrides),
+    unknownAttributes: [],
+    extensionElements: [],
+    ...(['subProcess', 'eventSubProcess', 'transaction', 'adHocSubProcess'].includes(type) ? { isExpanded: false } : {}),
+  };
+  return { ...base, ...overrides, properties: base.properties };
+}
+
+export function createEdge(source, target, overrides = {}) {
+  return {
+    id: uid('Flow'),
+    type: 'sequenceFlow',
+    source,
+    target,
+    name: '',
+    condition: '',
+    isDefault: false,
+    waypoints: null,
+    routeStyle: 'rounded',
+    cornerRadius: 14,
+    unknownAttributes: [],
+    extensionElements: [],
+    properties: { documentation: '', executionListeners: [], extensionAttributes: {}, messageRef: '', associationDirection: 'None' },
+    ...overrides,
+  };
+}
+
+export function createEmptyProcess(engine = 'flowable') {
+  return {
+    id: 'Process_1',
+    name: '未命名流程',
+    engine,
+    isExecutable: true,
+    targetNamespace: 'urn:bpmn-nova:process',
+    namespaceDeclarations: {},
+    properties: {
+      documentation: '',
+      candidateStarterUsers: '',
+      candidateStarterGroups: '',
+      executionListeners: [],
+      extensionAttributes: {},
+    },
+    resources: { messages: [], signals: [], errors: [], escalations: [] },
+    extensionElements: [],
+    nodes: [],
+    edges: [],
+    settings: {
+      direction: 'horizontal',
+      layoutDensity: 'balanced',
+      edgeStyle: 'rounded',
+      cornerRadius: 14,
+      showGrid: true,
+      // gridSize controls the visual / optional grid. Dragging is pixel-smooth
+      // by default and uses magnetic alignment instead of coarse grid steps.
+      gridSize: 16,
+      snapToGrid: false,
+      alignmentGuides: true,
+      alignmentThreshold: 7,
+      mergeGatewayConnections: true,
+    },
+  };
+}
+
+export function cloneModel(model) {
+  return JSON.parse(JSON.stringify(model));
+}
+
+export function getNode(model, id) {
+  return model.nodes.find((node) => node.id === id) || null;
+}
+
+export function getEdge(model, id) {
+  return model.edges.find((edge) => edge.id === id) || null;
+}
+
+export function clearConnectedWaypoints(model, nodeId) {
+  for (const edge of model.edges) {
+    if (edge.source === nodeId || edge.target === nodeId) edge.waypoints = null;
+  }
+}
+
+export function createSampleProcess(engine = 'flowable') {
+  const model = createEmptyProcess(engine);
+  model.id = 'Process_PurchaseApproval';
+  model.name = '采购申请审批流程';
+
+  const start = createNode('startEvent', 96, 318, { id: 'StartEvent_1', name: '开始' });
+  const submit = createNode('userTask', 210, 310, {
+    id: 'UserTask_Submit',
+    name: '提交采购申请',
+    properties: { assignee: '${initiator}', candidateUsers: '', candidateGroups: '', formKey: 'purchase-form' },
+  });
+  const manager = createNode('userTask', 516, 310, {
+    id: 'UserTask_Manager',
+    name: '部门负责人审批',
+    properties: { assignee: '${deptManager}', candidateUsers: '', candidateGroups: 'department-manager', formKey: 'approval-form' },
+  });
+  const gateway = createNode('exclusiveGateway', 836, 310, { id: 'Gateway_Amount', name: '金额判断' });
+  const director = createNode('userTask', 1038, 170, {
+    id: 'UserTask_Director',
+    name: '总经理审批',
+    properties: { assignee: '${director}', candidateUsers: '', candidateGroups: 'director', formKey: 'approval-form' },
+  });
+  const finance = createNode('userTask', 1038, 446, {
+    id: 'UserTask_Finance',
+    name: '财务复核',
+    properties: { assignee: '${finance}', candidateUsers: '', candidateGroups: 'finance', formKey: 'finance-form' },
+  });
+  const merge = createNode('exclusiveGateway', 1352, 310, { id: 'Gateway_Merge', name: '汇合' });
+  const archive = createNode('serviceTask', 1540, 310, {
+    id: 'ServiceTask_Archive',
+    name: '生成订单并通知',
+    properties: { implementationType: 'class', implementation: 'com.example.workflow.CreateOrderDelegate' },
+  });
+  const end = createNode('endEvent', 1860, 318, { id: 'EndEvent_1', name: '结束' });
+
+  model.nodes.push(start, submit, manager, gateway, director, finance, merge, archive, end);
+  model.edges.push(
+    createEdge(start.id, submit.id, { id: 'Flow_Start_Submit' }),
+    createEdge(submit.id, manager.id, { id: 'Flow_Submit_Manager' }),
+    createEdge(manager.id, gateway.id, { id: 'Flow_Manager_Gateway' }),
+    createEdge(gateway.id, director.id, { id: 'Flow_To_Director', name: '金额 ≥ 50,000', condition: '${amount >= 50000}' }),
+    createEdge(gateway.id, finance.id, { id: 'Flow_To_Finance', name: '金额 < 50,000', condition: '${amount < 50000}', isDefault: true }),
+    createEdge(director.id, merge.id, { id: 'Flow_Director_Merge', name: '审批通过' }),
+    createEdge(finance.id, merge.id, { id: 'Flow_Finance_Merge', name: '复核完成' }),
+    createEdge(merge.id, archive.id, { id: 'Flow_Merge_Archive' }),
+    createEdge(archive.id, end.id, { id: 'Flow_Archive_End' }),
+  );
+  return model;
+}

package/dist/modules/core/runtime-transition-route.js

@@ -0,0 +1,360 @@
+import { edgeWaypoints } from './layout.js';
+
+const EPSILON = 0.01;
+const DEFAULTS = Object.freeze({
+  nodeClearance: 16,
+  laneGap: 28,
+  laneSpacing: 20,
+  nearParallelDistance: 12,
+  anchorOverlapTolerance: 32,
+  maxLanesPerSide: 8,
+});
+
+function center(node) {
+  return { x: node.x + node.width / 2, y: node.y + node.height / 2 };
+}
+
+function expandRect(rect, amount) {
+  return {
+    x: rect.x - amount,
+    y: rect.y - amount,
+    width: rect.width + amount * 2,
+    height: rect.height + amount * 2,
+  };
+}
+
+function segments(points = []) {
+  return points.slice(0, -1).map((start, index) => ({ start, end: points[index + 1] }));
+}
+
+function orientation(segment) {
+  if (Math.abs(segment.start.x - segment.end.x) < EPSILON) return 'vertical';
+  if (Math.abs(segment.start.y - segment.end.y) < EPSILON) return 'horizontal';
+  return 'diagonal';
+}
+
+function interval(segment) {
+  return orientation(segment) === 'vertical'
+    ? [Math.min(segment.start.y, segment.end.y), Math.max(segment.start.y, segment.end.y)]
+    : [Math.min(segment.start.x, segment.end.x), Math.max(segment.start.x, segment.end.x)];
+}
+
+function intervalOverlap(a, b) {
+  return Math.max(0, Math.min(a[1], b[1]) - Math.max(a[0], b[0]));
+}
+
+function segmentHitsRect(segment, rect) {
+  const kind = orientation(segment);
+  const right = rect.x + rect.width;
+  const bottom = rect.y + rect.height;
+  if (kind === 'vertical') {
+    return segment.start.x > rect.x && segment.start.x < right
+      && intervalOverlap(interval(segment), [rect.y, bottom]) > EPSILON;
+  }
+  if (kind === 'horizontal') {
+    return segment.start.y > rect.y && segment.start.y < bottom
+      && intervalOverlap(interval(segment), [rect.x, right]) > EPSILON;
+  }
+  return false;
+}
+
+function compactPoints(points) {
+  return points.filter((point, index) => {
+    if (!index) return true;
+    const previous = points[index - 1];
+    return Math.abs(point.x - previous.x) >= EPSILON || Math.abs(point.y - previous.y) >= EPSILON;
+  });
+}
+
+function labelRect(point, size = {}) {
+  const width = Math.max(0, Number(size.width) || 0);
+  const height = Math.max(0, Number(size.height) || 0);
+  return { x: point.x - width / 2, y: point.y - height / 2, width, height };
+}
+
+function rectsIntersect(a, b) {
+  return a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y;
+}
+
+function selectLabelPoint(points, obstacles, occupiedRoutes, size) {
+  const routeSegments = segments(points)
+    .map((segment, index) => ({
+      ...segment,
+      index,
+      kind: orientation(segment),
+      length: Math.hypot(segment.end.x - segment.start.x, segment.end.y - segment.start.y),
+      point: {
+        x: (segment.start.x + segment.end.x) / 2,
+        y: (segment.start.y + segment.end.y) / 2,
+      },
+    }))
+    .filter((segment) => segment.length > EPSILON);
+  const occupiedSegments = occupiedRoutes.flatMap((route) => segments(route.points || route));
+  const scored = routeSegments.map((segment) => {
+    const rect = labelRect(segment.point, size);
+    const obstacleConflicts = obstacles.filter((obstacle) => rectsIntersect(rect, obstacle)).length;
+    const lineConflicts = occupiedSegments.filter((occupied) => segmentHitsRect(occupied, rect)).length;
+    return {
+      ...segment,
+      conflicts: obstacleConflicts + lineConflicts,
+      fitPenalty: segment.length < ((segment.kind === 'horizontal' ? Number(size?.width) : Number(size?.height)) || 0) + 12 ? 1 : 0,
+      // Horizontal labels are easier to associate with a horizontal route segment.
+      orientationPenalty: segment.kind === 'horizontal' ? 0 : 1,
+    };
+  });
+  scored.sort((a, b) => a.conflicts - b.conflicts
+    || a.fitPenalty - b.fitPenalty
+    || a.orientationPenalty - b.orientationPenalty
+    || b.length - a.length
+    || a.index - b.index);
+  return scored[0] || { point: points[0], conflicts: 0 };
+}
+
+function crossing(a, b) {
+  const ak = orientation(a);
+  const bk = orientation(b);
+  if (ak === bk || ak === 'diagonal' || bk === 'diagonal') return false;
+  const vertical = ak === 'vertical' ? a : b;
+  const horizontal = ak === 'horizontal' ? a : b;
+  const vx = vertical.start.x;
+  const hy = horizontal.start.y;
+  const [vy1, vy2] = interval(vertical);
+  const [hx1, hx2] = interval(horizontal);
+  return vx > hx1 + EPSILON && vx < hx2 - EPSILON && hy > vy1 + EPSILON && hy < vy2 - EPSILON;
+}
+
+function routeMetrics(points, occupiedRoutes, obstacles, config) {
+  const routeSegments = segments(points);
+  const occupiedSegments = occupiedRoutes.flatMap((route) => segments(route.points || route));
+  let overlapLength = 0;
+  let nearParallelLength = 0;
+  let crossings = 0;
+  for (const candidate of routeSegments) {
+    const candidateKind = orientation(candidate);
+    for (const occupied of occupiedSegments) {
+      const occupiedKind = orientation(occupied);
+      if (candidateKind === occupiedKind && ['horizontal', 'vertical'].includes(candidateKind)) {
+        const axisDistance = candidateKind === 'vertical'
+          ? Math.abs(candidate.start.x - occupied.start.x)
+          : Math.abs(candidate.start.y - occupied.start.y);
+        const shared = intervalOverlap(interval(candidate), interval(occupied));
+        if (axisDistance < EPSILON) overlapLength += Math.max(0, shared - config.anchorOverlapTolerance);
+        else if (axisDistance < config.nearParallelDistance) nearParallelLength += shared;
+      } else if (crossing(candidate, occupied)) crossings += 1;
+    }
+  }
+  const nodeHits = obstacles.reduce((count, rect) => count + (routeSegments.some((segment) => segmentHitsRect(segment, rect)) ? 1 : 0), 0);
+  const length = routeSegments.reduce((sum, segment) => sum + Math.hypot(segment.end.x - segment.start.x, segment.end.y - segment.start.y), 0);
+  return { nodeHits, overlapLength, nearParallelLength, crossings, bends: Math.max(0, points.length - 2), length };
+}
+
+function compareCandidates(a, b) {
+  const fields = ['nodeHits', 'portConflicts', 'overlapLength', 'labelConflicts', 'nearParallelLength', 'crossings', 'strategyPenalty', 'bends', 'length', 'order'];
+  for (const field of fields) {
+    const delta = (a[field] || 0) - (b[field] || 0);
+    if (Math.abs(delta) > EPSILON) return delta;
+  }
+  return 0;
+}
+
+function sideAnchor(node, side) {
+  if (side === 'left') return { x: node.x, y: node.y + node.height / 2 };
+  if (side === 'right') return { x: node.x + node.width, y: node.y + node.height / 2 };
+  if (side === 'top') return { x: node.x + node.width / 2, y: node.y };
+  return { x: node.x + node.width / 2, y: node.y + node.height };
+}
+
+function pointAnchorSide(node, point, tolerance = 2) {
+  if (!node || !point) return null;
+  const withinX = point.x >= node.x - tolerance && point.x <= node.x + node.width + tolerance;
+  const withinY = point.y >= node.y - tolerance && point.y <= node.y + node.height + tolerance;
+  const candidates = [
+    { side: 'left', distance: Math.abs(point.x - node.x), valid: withinY },
+    { side: 'right', distance: Math.abs(point.x - (node.x + node.width)), valid: withinY },
+    { side: 'top', distance: Math.abs(point.y - node.y), valid: withinX },
+    { side: 'bottom', distance: Math.abs(point.y - (node.y + node.height)), valid: withinX },
+  ].filter((candidate) => candidate.valid && candidate.distance <= tolerance);
+  candidates.sort((a, b) => a.distance - b.distance);
+  return candidates[0]?.side || null;
+}
+
+function sequenceFlowPortUsage(model, edges) {
+  const usage = new Map();
+  const add = (nodeId, side) => {
+    if (!side) return;
+    const key = `${nodeId}:${side}`;
+    usage.set(key, (usage.get(key) || 0) + 1);
+  };
+  for (const edge of edges) {
+    if ((edge.type || 'sequenceFlow') !== 'sequenceFlow') continue;
+    const points = edgeWaypoints(model, edge);
+    if (points.length < 2) continue;
+    const source = model.nodes.find((node) => node.id === edge.source);
+    const target = model.nodes.find((node) => node.id === edge.target);
+    add(edge.source, pointAnchorSide(source, points[0]));
+    add(edge.target, pointAnchorSide(target, points.at(-1)));
+  }
+  return usage;
+}
+
+function candidatePortConflicts(candidate, source, target, portUsage) {
+  return (portUsage.get(`${source.id}:${candidate.sourceSide}`) || 0)
+    + (portUsage.get(`${target.id}:${candidate.targetSide}`) || 0);
+}
+
+function outerSameSideCandidate(source, target, bounds, direction, side, laneIndex, config, leadDistance = config.laneGap) {
+  const start = sideAnchor(source, side);
+  const end = sideAnchor(target, side);
+  const laneOffset = config.laneGap + laneIndex * config.laneSpacing;
+  if (direction === 'vertical') {
+    const sign = side === 'left' ? -1 : 1;
+    const lane = side === 'left' ? bounds.left - laneOffset : bounds.right + laneOffset;
+    const sourceLead = { x: start.x + sign * leadDistance, y: start.y };
+    const targetLead = { x: end.x + sign * leadDistance, y: end.y };
+    return {
+      points: compactPoints([start, sourceLead, { x: lane, y: sourceLead.y }, { x: lane, y: targetLead.y }, targetLead, end]),
+      laneSide: side,
+      laneIndex,
+      sourceSide: side,
+      targetSide: side,
+      anchorStrategy: 'outer-same-side',
+      strategyPenalty: 0,
+    };
+  }
+  const sign = side === 'top' ? -1 : 1;
+  const lane = side === 'top' ? bounds.top - laneOffset : bounds.bottom + laneOffset;
+  const sourceLead = { x: start.x, y: start.y + sign * leadDistance };
+  const targetLead = { x: end.x, y: end.y + sign * leadDistance };
+  return {
+    points: compactPoints([start, sourceLead, { x: sourceLead.x, y: lane }, { x: targetLead.x, y: lane }, targetLead, end]),
+    laneSide: side,
+    laneIndex,
+    sourceSide: side,
+    targetSide: side,
+    anchorStrategy: 'outer-same-side',
+    strategyPenalty: 0,
+  };
+}
+
+function inferDirection(model, source, target) {
+  if (['horizontal', 'vertical'].includes(model?.settings?.direction)) return model.settings.direction;
+  const s = center(source);
+  const t = center(target);
+  return Math.abs(s.y - t.y) >= Math.abs(s.x - t.x) ? 'vertical' : 'horizontal';
+}
+
+function verticalCandidate(source, target, bounds, side, laneIndex, config, leadDistance = config.laneGap) {
+  const s = center(source);
+  const t = center(target);
+  const backwards = s.y >= t.y;
+  const start = backwards ? { x: s.x, y: source.y } : { x: s.x, y: source.y + source.height };
+  const end = backwards ? { x: t.x, y: target.y + target.height } : { x: t.x, y: target.y };
+  const sourceLead = { x: start.x, y: start.y + (backwards ? -leadDistance : leadDistance) };
+  const targetLead = { x: end.x, y: end.y + (backwards ? leadDistance : -leadDistance) };
+  const laneOffset = config.laneGap + laneIndex * config.laneSpacing;
+  const lane = side === 'left'
+    ? bounds.left - laneOffset
+    : bounds.right + laneOffset;
+  const points = compactPoints([start, sourceLead, { x: lane, y: sourceLead.y }, { x: lane, y: targetLead.y }, targetLead, end]);
+  return {
+    points,
+    laneSide: side,
+    laneIndex,
+    sourceSide: backwards ? 'top' : 'bottom',
+    targetSide: backwards ? 'bottom' : 'top',
+    anchorStrategy: 'flow-axis-fallback',
+    strategyPenalty: 1,
+  };
+}
+
+function horizontalCandidate(source, target, bounds, side, laneIndex, config, leadDistance = config.laneGap) {
+  const s = center(source);
+  const t = center(target);
+  const backwards = s.x >= t.x;
+  const start = backwards ? { x: source.x, y: s.y } : { x: source.x + source.width, y: s.y };
+  const end = backwards ? { x: target.x + target.width, y: t.y } : { x: target.x, y: t.y };
+  const sourceLead = { x: start.x + (backwards ? -leadDistance : leadDistance), y: start.y };
+  const targetLead = { x: end.x + (backwards ? leadDistance : -leadDistance), y: end.y };
+  const laneOffset = config.laneGap + laneIndex * config.laneSpacing;
+  const lane = side === 'top'
+    ? bounds.top - laneOffset
+    : bounds.bottom + laneOffset;
+  const points = compactPoints([start, sourceLead, { x: sourceLead.x, y: lane }, { x: targetLead.x, y: lane }, targetLead, end]);
+  return {
+    points,
+    laneSide: side,
+    laneIndex,
+    sourceSide: backwards ? 'left' : 'right',
+    targetSide: backwards ? 'right' : 'left',
+    anchorStrategy: 'flow-axis-fallback',
+    strategyPenalty: 1,
+  };
+}
+
+/**
+ * Routes a runtime-only rejection/return transition without mutating the BPMN model.
+ */
+export function routeRuntimeTransition(model, transition, options = {}) {
+  const source = model?.nodes?.find((node) => node.id === transition?.sourceElementId);
+  const target = model?.nodes?.find((node) => node.id === transition?.targetElementId);
+  if (!source || !target) return null;
+  const sourceScopeId = source.scopeId || model.id;
+  if ((target.scopeId || model.id) !== sourceScopeId) return null;
+  const config = { ...DEFAULTS, ...options };
+  const direction = inferDirection(model, source, target);
+  const scopedNodes = (model.nodes || []).filter((node) => (node.scopeId || model.id) === sourceScopeId);
+  const scopedEdges = (model.edges || []).filter((edge) => (edge.scopeId || model.id) === sourceScopeId);
+  const portUsage = sequenceFlowPortUsage(model, scopedEdges);
+  const occupiedRoutes = [
+    ...scopedEdges.map((edge) => edgeWaypoints(model, edge)),
+    ...(options.occupiedRoutes || []),
+  ];
+  const obstacles = [
+    ...scopedNodes
+      .filter((node) => node.id !== source.id && node.id !== target.id)
+      .map((node) => expandRect(node, config.nodeClearance)),
+    ...(options.obstacles || []),
+  ];
+  const bounds = scopedNodes.reduce((result, node) => ({
+    left: Math.min(result.left, node.x),
+    top: Math.min(result.top, node.y),
+    right: Math.max(result.right, node.x + node.width),
+    bottom: Math.max(result.bottom, node.y + node.height),
+  }), { left: Infinity, top: Infinity, right: -Infinity, bottom: -Infinity });
+  const labelObstacles = [
+    ...obstacles,
+    expandRect(source, config.nodeClearance),
+    expandRect(target, config.nodeClearance),
+  ];
+  const sides = direction === 'vertical' ? ['left', 'right'] : ['top', 'bottom'];
+  const candidates = [];
+  let order = 0;
+  const leadDistances = [config.laneGap, config.laneGap / 2, 0];
+  for (const side of sides) {
+    for (let laneIndex = 0; laneIndex < config.maxLanesPerSide; laneIndex += 1) {
+      for (const leadDistance of leadDistances) {
+        const strategyCandidates = [
+          outerSameSideCandidate(source, target, bounds, direction, side, laneIndex, config, leadDistance),
+          direction === 'vertical'
+            ? verticalCandidate(source, target, bounds, side, laneIndex, config, leadDistance)
+            : horizontalCandidate(source, target, bounds, side, laneIndex, config, leadDistance),
+        ];
+        for (const candidate of strategyCandidates) {
+          candidate.portConflicts = candidatePortConflicts(candidate, source, target, portUsage);
+          const label = selectLabelPoint(candidate.points, labelObstacles, occupiedRoutes, options.labelSize);
+          const labelConflicts = label.conflicts;
+          candidates.push({
+            ...candidate,
+            labelPoint: label.point,
+            ...routeMetrics(candidate.points, occupiedRoutes, obstacles, config),
+            labelConflicts,
+            order,
+          });
+          order += 1;
+        }
+      }
+    }
+  }
+  const selected = candidates.filter((candidate) => candidate.nodeHits === 0).sort(compareCandidates)[0];
+  return selected ? { ...selected, direction } : null;
+}