@bpmn-nova/studio 0.3.5-preview → 0.3.6-preview

package/dist/modules/runtime/index.js

@@ -1,3 +1,10 @@
+import { parseRuntimeInstant, formatRuntimeInstant, compareRuntimeOrder, runtimeInstant } from './time.js';
+import { pushDiagnostic } from './diagnostics.js';
+import { groupVisits, markEffectiveVisits, resolveEffectiveStatus, resolveVisitStatus } from './visits.js';
+
+export { parseRuntimeInstant, formatRuntimeInstant, compareRuntimeOrder } from './time.js';
+export { groupVisits, resolveVisitStatus, resolveEffectiveStatus } from './visits.js';
+
 const TERMINAL_PROCESS_STATUSES = new Set(['completed', 'terminated']);
 const ABNORMAL_TRANSITION_TYPES = new Set(['reject', 'return']);
 const APPROVAL_ACTION_LABELS = {
@@ -14,16 +21,21 @@ function normalizeParticipant(record = {}) {
   return null;
 }
 
+function stampInstant(value) {
+  return runtimeInstant(value);
+}
+
 function recordOrder(record, index) {
-  const stamp = record.startTime || record.endTime;
-  const parsed = stamp ? Date.parse(stamp.replace(' ', 'T')) : Number.NaN;
-  return Number.isFinite(parsed) ? parsed : index;
+  return stampInstant(record.startTime || record.endTime);
 }
 
-function runtimeOrder(value, index) {
-  const stamp = value?.occurredAt || value?.time || value?.endTime || value?.startTime;
-  const parsed = stamp ? Date.parse(String(stamp).replace(' ', 'T')) : Number.NaN;
-  return Number.isFinite(parsed) ? parsed : index;
+function runtimeOrder(value) {
+  return stampInstant(value?.occurredAt || value?.time || value?.endTime || value?.startTime);
+}
+
+function isAfter(left, right) {
+  if (left == null || right == null) return false;
+  return left > right;
 }
 
 function normalizeRuntimeAsset(asset) {
@@ -107,12 +119,14 @@ function approvalActionLabel(action) {
 }
 
 function summarizeApprovalActions(actions = []) {
-  const latestAction = [...actions].reverse().find((action) => action.plainText || action.assetCount) || actions.at(-1) || null;
+  const latestAction = actions.at(-1) || null;
+  const latestNonEmptyComment = [...actions].reverse().find((action) => action.plainText || action.assetCount) || null;
   const assetSummary = latestAction
     ? [latestAction.imageCount ? `${latestAction.imageCount} 张图片` : '', latestAction.fileCount ? `${latestAction.fileCount} 个附件` : ''].filter(Boolean).join(' · ')
     : '';
   return {
     latestAction,
+    latestNonEmptyComment,
     actionText: latestAction?.plainText || '',
     actionSummary: latestAction ? [latestAction.label, latestAction.plainText, assetSummary].filter(Boolean).join(' · ') : '',
     imageCount: actions.reduce((sum, action) => sum + action.imageCount, 0),
@@ -121,31 +135,6 @@ function summarizeApprovalActions(actions = []) {
   };
 }
 
-function groupVisits(records = []) {
-  const groups = new Map();
-  records.forEach((record, index) => {
-    const key = record.visitId
-      ? `visit:${record.visitId}`
-      : record.multiInstanceId
-        ? `multi:${record.multiInstanceId}`
-        : `record:${record.id || index}`;
-    if (!groups.has(key)) groups.set(key, { id: record.visitId || record.multiInstanceId || record.id || String(index), records: [], order: recordOrder(record, index) });
-    const visit = groups.get(key);
-    visit.records.push(record);
-    visit.order = Math.max(visit.order, recordOrder(record, index));
-  });
-  return [...groups.values()].sort((a, b) => a.order - b.order).map((visit, index) => ({ ...visit, round: index + 1 }));
-}
-
-function resolveVisitStatus(records = []) {
-  if (!records.length) return 'idle';
-  if (records.some((item) => item.status === 'failed')) return 'failed';
-  if (records.some((item) => item.status === 'active')) return 'active';
-  if (records.every((item) => item.status === 'skipped')) return 'skipped';
-  if (records.some((item) => item.status === 'cancelled') && !records.some((item) => item.status === 'completed')) return 'cancelled';
-  return 'completed';
-}
-
 function uniqueParticipants(records = []) {
   const seen = new Set();
   const result = [];
@@ -180,16 +169,146 @@ function baseStatusLabel(status) {
   }[status] || status;
 }
 
-function transitionOrder(transition, index) {
-  const stamp = transition.occurredAt || transition.time;
-  const parsed = stamp ? Date.parse(stamp.replace(' ', 'T')) : Number.NaN;
-  return Number.isFinite(parsed) ? parsed : index;
+function transitionOrder(transition) {
+  return stampInstant(transition.occurredAt || transition.time);
+}
+
+function edgeVisitOrder(visit) {
+  return stampInstant(visit.occurredAt || visit.time);
+}
+
+function collectIdentityDiagnostics(runtime, { model = null, diagnostics }) {
+  const activityIds = new Set();
+  const actionIds = new Set();
+  const transitionIds = new Set();
+  const edgeVisitIds = new Set();
+  const visitOwners = new Map();
+  const nodeIds = new Set((model?.nodes || []).map((node) => node.id));
+  const edgeIds = new Set((model?.edges || []).map((edge) => edge.id));
+
+  runtime.activities.forEach((record, index) => {
+    const fieldPath = `activities[${index}]`;
+    if (record.id) {
+      if (activityIds.has(record.id)) pushDiagnostic(diagnostics, { code: 'duplicate-activity-id', level: 'error', message: '工作项 ID 重复。', fieldPath, activityId: record.id, elementId: record.elementId });
+      activityIds.add(record.id);
+    }
+    if (record.visitId) {
+      const owner = visitOwners.get(record.visitId);
+      if (owner && owner !== record.elementId) {
+        pushDiagnostic(diagnostics, { code: 'visit-element-mismatch', level: 'error', message: '同一 visitId 关联了不同 BPMN 元素。', fieldPath, visitId: record.visitId, elementId: record.elementId });
+      }
+      visitOwners.set(record.visitId, record.elementId);
+    }
+    ['startTime', 'endTime'].forEach((field) => {
+      const parsed = parseRuntimeInstant(record[field]);
+      if (parsed.kind === 'invalid') pushDiagnostic(diagnostics, { code: 'invalid-time', level: 'warning', message: '时间无法解析。', fieldPath: `${fieldPath}.${field}`, activityId: record.id, elementId: record.elementId });
+      else if (parsed.kind === 'naive') pushDiagnostic(diagnostics, { code: 'naive-time', level: 'info', message: '时间缺少时区，比较结果可能因环境而异。', fieldPath: `${fieldPath}.${field}`, activityId: record.id, elementId: record.elementId });
+    });
+    if (model && record.elementId && !nodeIds.has(record.elementId)) {
+      pushDiagnostic(diagnostics, { code: 'unknown-element', level: 'error', message: '工作项引用了不存在的 BPMN 元素。', fieldPath: `${fieldPath}.elementId`, activityId: record.id, elementId: record.elementId });
+    }
+  });
+
+  runtime.actions.forEach((action, index) => {
+    const fieldPath = `actions[${index}]`;
+    if (actionIds.has(action.id)) pushDiagnostic(diagnostics, { code: 'duplicate-action-id', level: 'error', message: '操作 ID 重复。', fieldPath, actionId: action.id, elementId: action.elementId });
+    actionIds.add(action.id);
+    if (action.activityId && !activityIds.has(action.activityId) && !String(action.id).startsWith('legacy-')) {
+      pushDiagnostic(diagnostics, { code: 'unknown-activity', level: 'error', message: '操作引用了不存在的工作项。', fieldPath: `${fieldPath}.activityId`, actionId: action.id, activityId: action.activityId, elementId: action.elementId });
+    }
+    const record = runtime.activities.find((item) => item.id && item.id === action.activityId);
+    if (record && ((action.elementId && record.elementId !== action.elementId) || (action.visitId && record.visitId && record.visitId !== action.visitId))) {
+      pushDiagnostic(diagnostics, { code: 'action-identity-mismatch', level: 'error', message: '操作与工作项的元素或 Visit 不一致。', fieldPath, actionId: action.id, activityId: action.activityId, elementId: action.elementId, visitId: action.visitId });
+    }
+    const parsed = parseRuntimeInstant(action.occurredAt);
+    if (parsed.kind === 'invalid') pushDiagnostic(diagnostics, { code: 'invalid-time', level: 'warning', message: '操作时间无法解析。', fieldPath: `${fieldPath}.occurredAt`, actionId: action.id });
+    else if (parsed.kind === 'naive') pushDiagnostic(diagnostics, { code: 'naive-time', level: 'info', message: '操作时间缺少时区。', fieldPath: `${fieldPath}.occurredAt`, actionId: action.id });
+    else if (parsed.kind === 'missing' && !String(action.id).startsWith('legacy-')) {
+      pushDiagnostic(diagnostics, { code: 'missing-time', level: 'warning', message: '操作缺少时间，排序仅用于展示。', fieldPath: `${fieldPath}.occurredAt`, actionId: action.id });
+    }
+  });
+
+  runtime.transitions.forEach((transition, index) => {
+    const fieldPath = `transitions[${index}]`;
+    const id = transition.id || `runtime-transition-${index + 1}`;
+    if (transitionIds.has(id)) pushDiagnostic(diagnostics, { code: 'duplicate-transition-id', level: 'error', message: '跳转 ID 重复。', fieldPath, transitionId: id });
+    transitionIds.add(id);
+    if (transition.sourceActivityId && !activityIds.has(transition.sourceActivityId)) {
+      pushDiagnostic(diagnostics, { code: 'unknown-activity', level: 'error', message: '跳转引用了不存在的来源工作项。', fieldPath: `${fieldPath}.sourceActivityId`, transitionId: id, activityId: transition.sourceActivityId, elementId: transition.sourceElementId });
+    }
+    if (transition.actionId && !actionIds.has(transition.actionId) && !String(transition.actionId).startsWith('legacy-')) {
+      pushDiagnostic(diagnostics, { code: 'unknown-action', level: 'error', message: '跳转引用了不存在的操作。', fieldPath: `${fieldPath}.actionId`, transitionId: id, actionId: transition.actionId });
+    }
+    if (model && transition.sourceElementId && !nodeIds.has(transition.sourceElementId)) {
+      pushDiagnostic(diagnostics, { code: 'unknown-element', level: 'error', message: '跳转来源元素不存在。', fieldPath: `${fieldPath}.sourceElementId`, transitionId: id, elementId: transition.sourceElementId });
+    }
+    if (model && transition.targetElementId && !nodeIds.has(transition.targetElementId)) {
+      pushDiagnostic(diagnostics, { code: 'unknown-element', level: 'error', message: '跳转目标元素不存在。', fieldPath: `${fieldPath}.targetElementId`, transitionId: id, elementId: transition.targetElementId });
+    }
+    const parsed = parseRuntimeInstant(transition.occurredAt || transition.time);
+    if ((transition.occurredAt || transition.time) && parsed.kind === 'invalid') {
+      pushDiagnostic(diagnostics, { code: 'invalid-time', level: 'warning', message: '跳转时间无法解析。', fieldPath: `${fieldPath}.occurredAt`, transitionId: id });
+    } else if (parsed.kind === 'naive') {
+      pushDiagnostic(diagnostics, { code: 'naive-time', level: 'info', message: '跳转时间缺少时区。', fieldPath: `${fieldPath}.occurredAt`, transitionId: id });
+    }
+  });
+
+  runtime.edgeVisits.forEach((visit, index) => {
+    if (visit.id) {
+      if (edgeVisitIds.has(visit.id)) pushDiagnostic(diagnostics, { code: 'duplicate-edge-visit-id', level: 'error', message: '连线经过 ID 重复。', fieldPath: `edgeVisits[${index}]`, edgeId: visit.edgeId });
+      edgeVisitIds.add(visit.id);
+    }
+    if (model && visit.edgeId && !edgeIds.has(visit.edgeId)) {
+      pushDiagnostic(diagnostics, { code: 'unknown-edge', level: 'error', message: '连线经过引用了不存在的 BPMN 连线。', fieldPath: `edgeVisits[${index}].edgeId`, edgeId: visit.edgeId });
+    }
+  });
 }
 
-function edgeVisitOrder(visit, index) {
-  const stamp = visit.occurredAt || visit.time;
-  const parsed = stamp ? Date.parse(stamp.replace(' ', 'T')) : Number.NaN;
-  return Number.isFinite(parsed) ? parsed : index;
+function resolveInvalidatedElements(transition, { activities, model, diagnostics }) {
+  const legacy = Array.isArray(transition.invalidatedActivityIds) ? transition.invalidatedActivityIds.map(String) : null;
+  const next = Array.isArray(transition.invalidatedElementIds) ? transition.invalidatedElementIds.map(String) : null;
+  const activityIds = new Set(activities.map((record) => record.id).filter(Boolean));
+  const nodeIds = new Set((model?.nodes || []).map((node) => node.id));
+  const warnIds = (ids, field) => {
+    ids.forEach((id) => {
+      if (activityIds.has(id) && !nodeIds.has(id)) {
+        pushDiagnostic(diagnostics, {
+          code: 'invalidation-work-item-id',
+          level: 'warning',
+          message: '失效字段收到工作项 ID，该字段只接受 BPMN 元素 ID。',
+          fieldPath: `transitions.${transition.id}.${field}`,
+          transitionId: transition.id,
+          activityId: id,
+        });
+      } else if (model && !nodeIds.has(id)) {
+        pushDiagnostic(diagnostics, {
+          code: 'unknown-element',
+          level: 'error',
+          message: '失效范围引用了不存在的 BPMN 元素。',
+          fieldPath: `transitions.${transition.id}.${field}`,
+          transitionId: transition.id,
+          elementId: id,
+        });
+      }
+    });
+  };
+  if (legacy && next) {
+    const same = legacy.length === next.length && [...legacy].sort().every((id, index) => id === [...next].sort()[index]);
+    if (!same) {
+      pushDiagnostic(diagnostics, {
+        code: 'invalidation-field-conflict',
+        level: 'warning',
+        message: 'invalidatedElementIds 与 invalidatedActivityIds 不一致，已按元素字段生效。',
+        fieldPath: `transitions.${transition.id}.invalidatedElementIds`,
+        transitionId: transition.id,
+      });
+    }
+    warnIds(next, 'invalidatedElementIds');
+    return [...next];
+  }
+  const resolved = [...(next || legacy || [])];
+  warnIds(resolved, next ? 'invalidatedElementIds' : 'invalidatedActivityIds');
+  return resolved;
 }
 
 function inferInvalidatedPath(model, runtime, transition) {
@@ -227,8 +346,9 @@ function inferInvalidatedPath(model, runtime, transition) {
   return { activityIds: paths[0].nodeIds.slice(1), edgeIds: paths[0].edgeIds, issues: [] };
 }
 
-export function normalizeRuntime(snapshot = {}) {
+export function normalizeRuntime(snapshot = {}, options = {}) {
   snapshot = snapshot || {};
+  const diagnostics = options.diagnostics || null;
   const activities = Array.isArray(snapshot.activities)
     ? snapshot.activities.map((record) => ({ ...record, participant: normalizeParticipant(record) || undefined }))
     : [];
@@ -274,10 +394,13 @@ export function normalizeRuntime(snapshot = {}) {
     ? snapshot.edgeVisits.map((visit, index) => ({ id: visit.id || `runtime-edge-visit-${index + 1}`, status: visit.status || 'effective', ...visit }))
     : [];
   const orderedActions = actions
-    .map((action, index) => ({ action, order: runtimeOrder(action, index), index }))
-    .sort((a, b) => (a.order - b.order) || (a.index - b.index))
+    .map((action, index) => ({ action, index }))
+    .sort((left, right) => compareRuntimeOrder(
+      { instant: runtimeOrder(left.action), index: left.index },
+      { instant: runtimeOrder(right.action), index: right.index },
+    ))
     .map(({ action }) => action);
-  return {
+  const normalized = {
     ...snapshot,
     processInstanceId: snapshot.processInstanceId || '',
     status: snapshot.status || 'running',
@@ -287,20 +410,45 @@ export function normalizeRuntime(snapshot = {}) {
     transitions,
     edgeVisits,
   };
+  if (diagnostics) collectIdentityDiagnostics(normalized, { model: options.model, diagnostics });
+  return normalized;
 }
 
-export function activityState(runtime, elementId) {
-  if (!runtime) return { status: 'idle', records: [], latestRecords: [], visits: [] };
+export function activityState(runtime, elementId, options = {}) {
+  if (!runtime) return { status: 'idle', records: [], latestRecords: [], visits: [], effectiveVisits: [] };
   const records = runtime.activities.filter((item) => item.elementId === elementId);
-  const visits = groupVisits(records);
-  const latestRecords = visits.at(-1)?.records || [];
-  return { status: resolveVisitStatus(latestRecords), records, latestRecords, visits };
+  const visits = markEffectiveVisits(groupVisits(records), {
+    elementId,
+    transitions: runtime.transitions || [],
+    diagnostics: options.diagnostics || null,
+  });
+  const effectiveVisits = visits.filter((visit) => visit.effective);
+  const latestRecords = (effectiveVisits.at(-1) || visits.at(-1))?.records || [];
+  return {
+    status: resolveEffectiveStatus(effectiveVisits.length ? effectiveVisits : visits),
+    records,
+    latestRecords,
+    visits,
+    effectiveVisits,
+  };
 }
 
-export function createRuntimePresentation({ model, runtime, appearance = null } = {}) {
-  const normalized = normalizeRuntime(runtime);
+export function inspectRuntime(snapshot, options = {}) {
+  const diagnostics = [];
+  const presentation = createRuntimePresentation({
+    model: options.model || { id: '', nodes: [], edges: [] },
+    runtime: snapshot,
+    appearance: options.appearance || null,
+    diagnostics,
+  });
+  return { runtime: presentation.runtime, diagnostics: presentation.diagnostics };
+}
+
+export function createRuntimePresentation({ model, runtime, appearance = null, diagnostics = null } = {}) {
+  const collected = diagnostics || [];
+  const normalized = normalizeRuntime(runtime, { diagnostics: collected, model });
   const nodes = new Map((model?.nodes || []).map((node) => [node.id, node]));
-  const activityStates = new Map((model?.nodes || []).map((node) => [node.id, activityState(normalized, node.id)]));
+  const activityStates = new Map((model?.nodes || []).map((node) => [node.id, activityState(normalized, node.id, { diagnostics: collected })]));
   const nodePresentations = new Map();
   const actionPresentations = normalized.actions.map((action, index) => {
     const assets = action.content.assets || [];
@@ -319,7 +467,7 @@ export function createRuntimePresentation({ model, runtime, appearance = null }
       imageCount: images.length,
       fileCount: files.length,
       assetCount: images.length + files.length,
-      order: runtimeOrder(action, index),
+      order: runtimeOrder(action) ?? index,
     };
     const resolvedAppearance = appearance?.resolveAction?.(baseAction);
     return resolvedAppearance
@@ -328,20 +476,27 @@ export function createRuntimePresentation({ model, runtime, appearance = null }
   });
   const actionMap = new Map(actionPresentations.map((action) => [action.id, action]));
   const rawTransitions = normalized.transitions
-    .map((transition, index) => ({ ...transition, order: transitionOrder(transition, index) }))
-    .sort((a, b) => a.order - b.order);
+    .map((transition, index) => ({ ...transition, order: transitionOrder(transition) ?? index }))
+    .sort((left, right) => compareRuntimeOrder(
+      { instant: transitionOrder(left), index: left.order },
+      { instant: transitionOrder(right), index: right.order },
+    ));
   const transitionPresentations = rawTransitions.map((transition) => {
     const targetName = nodes.get(transition.targetElementId)?.name || transition.targetElementId || '';
     const labelPrefix = transition.type === 'reject' ? '驳回至' : transition.type === 'return' ? '退回至' : transition.type === 'skip' ? '跳过' : '流转至';
     const targetState = activityStates.get(transition.targetElementId);
-    const targetRecordsAfter = (targetState?.records || []).filter((record, index) => recordOrder(record, index) > transition.order);
+    const targetRecordsAfter = (targetState?.records || []).filter((record) => isAfter(recordOrder(record), transition.order));
     const targetStatusAfter = resolveVisitStatus(groupVisits(targetRecordsAfter).at(-1)?.records || []);
     const state = transition.state || (ABNORMAL_TRANSITION_TYPES.has(transition.type)
       ? (targetRecordsAfter.length && targetStatusAfter !== 'active' ? 'resolved' : 'active')
       : 'resolved');
-    const hasExplicitInvalidation = Array.isArray(transition.invalidatedActivityIds) || Array.isArray(transition.invalidatedEdgeIds);
+    const hasExplicitInvalidation = Array.isArray(transition.invalidatedElementIds) || Array.isArray(transition.invalidatedActivityIds) || Array.isArray(transition.invalidatedEdgeIds);
     const invalidation = hasExplicitInvalidation
-      ? { activityIds: [...(transition.invalidatedActivityIds || [])], edgeIds: [...(transition.invalidatedEdgeIds || [])], issues: [] }
+      ? {
+        activityIds: resolveInvalidatedElements(transition, { activities: normalized.activities, model, diagnostics: collected }),
+        edgeIds: [...(transition.invalidatedEdgeIds || [])],
+        issues: [],
+      }
       : ABNORMAL_TRANSITION_TYPES.has(transition.type)
         ? inferInvalidatedPath(model, normalized, transition)
         : { activityIds: [], edgeIds: [], issues: [] };
@@ -354,6 +509,7 @@ export function createRuntimePresentation({ model, runtime, appearance = null }
       state,
       visible: ABNORMAL_TRANSITION_TYPES.has(transition.type) && state === 'active',
       resolvedAt: transition.resolvedAt || (state === 'resolved' ? targetRecordsAfter.map((record) => record.endTime).filter(Boolean).at(-1) : undefined),
+      invalidatedElementIds: invalidation.activityIds,
       invalidatedActivityIds: invalidation.activityIds,
       invalidatedEdgeIds: invalidation.edgeIds,
       issues: invalidation.issues,
@@ -365,15 +521,38 @@ export function createRuntimePresentation({ model, runtime, appearance = null }
   const invalidatedNodes = new Map();
   const invalidatedEdges = new Map();
   const hasActivityAfter = (elementId, transition) => (activityStates.get(elementId)?.records || [])
-    .some((record, index) => recordOrder(record, index) > transition.order);
+    .some((record) => isAfter(recordOrder(record), transition.order));
   const hasEdgeVisitAfter = (edgeId, transition) => {
     const edgeVisits = normalized.edgeVisits.filter((visit) => visit.edgeId === edgeId);
-    if (edgeVisits.length) return edgeVisits.some((visit, index) => visit.status !== 'superseded' && edgeVisitOrder(visit, index) > transition.order);
+    if (edgeVisits.length) return edgeVisits.some((visit) => visit.status !== 'superseded' && isAfter(edgeVisitOrder(visit), transition.order));
     const edge = model?.edges?.find((item) => item.id === edgeId);
     return edge ? hasActivityAfter(edge.target, transition) : false;
   };
   for (const transition of transitionPresentations.filter((item) => ABNORMAL_TRANSITION_TYPES.has(item.type))) {
-    for (const elementId of transition.invalidatedActivityIds) if (!hasActivityAfter(elementId, transition)) invalidatedNodes.set(elementId, transition);
+    for (const elementId of transition.invalidatedActivityIds) {
+      const state = activityStates.get(elementId);
+      const concurrent = (state?.effectiveVisits || []).length > 1;
+      if (concurrent) {
+        pushDiagnostic(collected, {
+          code: 'element-invalidation-with-concurrent-visits',
+          level: 'warning',
+          message: '元素级失效遇到多个有效 Visit，未取消无关的并发执行。',
+          fieldPath: `transitions.${transition.id}.invalidatedElementIds`,
+          transitionId: transition.id,
+          elementId,
+        });
+        const endedBefore = (state?.visits || []).filter((visit) => {
+          const ended = visit.records.map((record) => recordOrder(record)).filter((value) => value != null);
+          const last = ended.length ? Math.max(...ended) : null;
+          return last != null && last <= transition.order;
+        });
+        if (endedBefore.length && endedBefore.length < (state?.visits || []).length && !hasActivityAfter(elementId, transition)) {
+          invalidatedNodes.set(elementId, transition);
+        }
+        continue;
+      }
+      if (!hasActivityAfter(elementId, transition)) invalidatedNodes.set(elementId, transition);
+    }
     for (const edgeId of transition.invalidatedEdgeIds) if (!hasEdgeVisitAfter(edgeId, transition)) invalidatedEdges.set(edgeId, transition);
   }
 
@@ -384,32 +563,40 @@ export function createRuntimePresentation({ model, runtime, appearance = null }
       const visitActions = actions.filter((action) => action.visitId === visit.id);
       return { ...visit, actions: visitActions, ...summarizeApprovalActions(visitActions) };
     });
-    const latestVisit = visits.at(-1) || null;
+    const effectiveVisits = visits.filter((visit) => visit.effective);
+    const latestVisit = effectiveVisits.at(-1) || visits.at(-1) || null;
     const latestRecords = latestVisit?.records || [];
-    const participants = uniqueParticipants(latestRecords);
+    const currentRecords = effectiveVisits.flatMap((visit) => visit.records);
+    const currentActions = effectiveVisits.flatMap((visit) => visit.actions);
+    const participants = uniqueParticipants(currentRecords.length ? currentRecords : latestRecords);
     const approvalMode = latestRecords.find((item) => item.approvalMode)?.approvalMode || null;
     const multiInstanceMode = latestRecords.find((item) => item.multiInstanceMode)?.multiInstanceMode || null;
     const declaredTotal = latestRecords.reduce((max, item) => Math.max(max, Number(item.totalInstances) || 0), 0);
-    const total = Math.max(declaredTotal, latestRecords.length, participants.length);
+    const total = Math.max(declaredTotal, latestRecords.length, uniqueParticipants(latestRecords).length);
     const completed = latestRecords.filter((item) => item.status === 'completed').length;
     const required = latestRecords.reduce((max, item) => Math.max(max, Number(item.requiredInstances) || 0), 0) || (approvalMode === 'any' ? 1 : total);
     const inboundReentry = transitionPresentations.some((item) => ABNORMAL_TRANSITION_TYPES.has(item.type) && item.targetElementId === node.id);
     const latestSourceRejection = [...transitionPresentations].reverse().find((item) => item.type === 'reject' && item.sourceElementId === node.id);
     const rejectionSource = latestRecords.some((item) => item.outcome === 'rejected')
-      || (latestSourceRejection && (!latestVisit || latestSourceRejection.order >= latestVisit.order));
+      || (latestSourceRejection && (!latestVisit || (latestSourceRejection.order ?? 0) >= (recordOrder(latestRecords.at(-1) || {}) ?? 0)));
     const skipped = !state.records.length && transitionPresentations.some((item) => item.type === 'skip' && item.targetElementId === node.id);
     let status = skipped ? 'skipped' : state.status;
-    if (rejectionSource && status === 'completed') status = 'rejected';
+    if (rejectionSource && status === 'completed' && effectiveVisits.length <= 1) status = 'rejected';
     const isReentry = inboundReentry && Boolean(latestVisit) && (latestVisit.round > 1 || status === 'active');
     const superseded = invalidatedNodes.has(node.id);
     const pathStatus = superseded || status === 'rejected' ? 'idle' : status;
 
     let statusLabel = baseStatusLabel(status);
-    if (isReentry && status === 'active') statusLabel = '重新审批';
+    const activeVisitCount = effectiveVisits.filter((visit) => resolveVisitStatus(visit.records) === 'active').length;
+    if (effectiveVisits.length > 1 && activeVisitCount) {
+      statusLabel = activeVisitCount === effectiveVisits.length
+        ? `处理中 ${activeVisitCount} 项执行`
+        : `处理中 ${activeVisitCount}/${effectiveVisits.length} 项执行`;
+    } else if (isReentry && status === 'active') statusLabel = '重新审批';
     else if (status === 'active' || status === 'completed') {
       if (approvalMode === 'all') statusLabel = `${multiInstanceMode === 'sequential' ? '顺序会签' : '会签'} ${completed}/${total || required}`;
       else if (approvalMode === 'any') statusLabel = `或签 ${completed}/${total || required}`;
-      else if (participants.length > 1) statusLabel = `多人审批 ${completed}/${total}`;
+      else if (participants.length > 1 && effectiveVisits.length <= 1) statusLabel = `多人审批 ${completed}/${total}`;
     }
 
     let summary = participantSummary(participants);
@@ -424,30 +611,35 @@ export function createRuntimePresentation({ model, runtime, appearance = null }
     }
 
     const relatedTransitions = transitionPresentations.filter((item) => item.sourceElementId === node.id || item.targetElementId === node.id);
-    const actionSummary = summarizeApprovalActions(actions);
+    const currentSummary = summarizeApprovalActions(currentActions);
+    const historySummary = summarizeApprovalActions(actions);
     nodePresentations.set(node.id, {
       elementId: node.id, status, pathStatus, superseded, statusLabel, summary, fullSummary: participants.map((item) => item.name).join('、') || summary,
       participants, approvalMode, multiInstanceMode, completed, total, required, round: latestVisit?.round || 0,
-      records: state.records, latestRecords, visits, transitions: relatedTransitions, actions, ...actionSummary,
+      records: state.records, latestRecords, visits, effectiveVisits, transitions: relatedTransitions, actions,
+      ...currentSummary,
+      latestNonEmptyComment: historySummary.latestNonEmptyComment,
       isReentry,
       hasDetails: Boolean(state.records.length || actions.length || relatedTransitions.length),
     });
   }
 
+  const frozenDiagnostics = Object.freeze(collected.slice());
+  const emptyNode = (elementId) => ({
+    elementId, status: 'idle', pathStatus: 'idle', superseded: false, statusLabel: '未到达', summary: '', fullSummary: '', participants: [], approvalMode: null,
+    multiInstanceMode: null, completed: 0, total: 0, required: 0, round: 0, records: [], latestRecords: [], visits: [], effectiveVisits: [], transitions: [], actions: [], latestAction: null,
+    latestNonEmptyComment: null, actionText: '', actionSummary: '', imageCount: 0, fileCount: 0, assetCount: 0, isReentry: false, hasDetails: false,
+  });
+
   return {
     runtime: normalized,
-    getNode(elementId) {
-      return nodePresentations.get(elementId) || {
-        elementId, status: 'idle', pathStatus: 'idle', superseded: false, statusLabel: '未到达', summary: '', fullSummary: '', participants: [], approvalMode: null,
-        multiInstanceMode: null, completed: 0, total: 0, required: 0, round: 0, records: [], latestRecords: [], visits: [], transitions: [], actions: [], latestAction: null,
-        actionText: '', actionSummary: '', imageCount: 0, fileCount: 0, assetCount: 0, isReentry: false, hasDetails: false,
-      };
-    },
+    diagnostics: frozenDiagnostics,
+    getNode(elementId) { return nodePresentations.get(elementId) || emptyNode(elementId); },
     getEdge(edgeId) {
       const edgeVisits = normalized.edgeVisits.filter((visit) => visit.edgeId === edgeId);
       const latestVisit = edgeVisits
-        .map((visit, index) => ({ visit, order: edgeVisitOrder(visit, index) }))
-        .sort((a, b) => a.order - b.order)
+        .map((visit, index) => ({ visit, index, instant: edgeVisitOrder(visit) }))
+        .sort((left, right) => compareRuntimeOrder(left, right))
         .at(-1)?.visit;
       const visited = normalized.visitedEdges.includes(edgeId) || edgeVisits.length > 0;
       const superseded = invalidatedEdges.has(edgeId) || latestVisit?.status === 'superseded';

package/dist/modules/runtime/time.js

@@ -0,0 +1,41 @@
+const OFFSET_PATTERN = /(?:Z|[+-]\d{2}:?\d{2})$/i;
+
+export function parseRuntimeInstant(value) {
+  if (value == null || value === '') return { instant: null, raw: '', kind: 'missing' };
+  const raw = String(value);
+  const trimmed = raw.trim();
+  if (!trimmed) return { instant: null, raw, kind: 'missing' };
+  const hasOffset = OFFSET_PATTERN.test(trimmed);
+  const normalized = !trimmed.includes('T') && trimmed.includes(' ') ? trimmed.replace(' ', 'T') : trimmed;
+  const instant = Date.parse(normalized);
+  if (!Number.isFinite(instant)) return { instant: null, raw, kind: 'invalid' };
+  if (hasOffset) return { instant, raw, kind: /Z$/i.test(trimmed) ? 'z' : 'offset' };
+  return { instant, raw, kind: 'naive' };
+}
+
+export function formatRuntimeInstant(value) {
+  const parsed = value && typeof value === 'object' && 'raw' in value ? value : parseRuntimeInstant(value);
+  if (!parsed?.raw) return '';
+  return String(parsed.raw).trim().replace('T', ' ');
+}
+
+export function compareRuntimeOrder(left, right) {
+  const a = normalizeOrderKey(left);
+  const b = normalizeOrderKey(right);
+  if (a.instant != null && b.instant != null && a.instant !== b.instant) return a.instant - b.instant;
+  if (a.instant != null && b.instant == null) return -1;
+  if (a.instant == null && b.instant != null) return 1;
+  return (a.index || 0) - (b.index || 0);
+}
+
+export function runtimeInstant(value) {
+  return parseRuntimeInstant(value).instant;
+}
+
+function normalizeOrderKey(value) {
+  if (value && typeof value === 'object' && ('instant' in value || 'index' in value || 'kind' in value)) {
+    return { instant: value.instant ?? null, index: Number.isFinite(value.index) ? value.index : 0, kind: value.kind };
+  }
+  const parsed = parseRuntimeInstant(value);
+  return { instant: parsed.instant, index: 0, kind: parsed.kind };
+}