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

package/dist/modules/viewer/runtime-trace.js

@@ -0,0 +1,574 @@
+import {
+  beautify,
+  cloneModel,
+  createEdge,
+  EMBEDDED_SUBPROCESS_TYPES,
+  getScopeGraph,
+  NODE_DEFINITIONS,
+} from '../core/index.js';
+import { createRuntimePresentation, normalizeRuntime } from '../runtime/index.js';
+
+const HUMAN_TASKS = new Set(['userTask', 'manualTask', 'callActivity']);
+const AUTOMATED_TASKS = new Set(['serviceTask', 'scriptTask', 'businessRuleTask', 'sendTask', 'receiveTask']);
+const CONDITIONAL_GATEWAYS = new Set(['exclusiveGateway', 'inclusiveGateway', 'eventBasedGateway', 'complexGateway']);
+const ABNORMAL_TRANSITIONS = new Set(['reject', 'return']);
+
+function timestamp(value, fallback = 0) {
+  if (!value) return fallback;
+  const parsed = Date.parse(String(value).replace(' ', 'T'));
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function recordOrder(record, index = 0) {
+  return timestamp(record.startTime || record.endTime, index);
+}
+
+function transitionOrder(transition, index = 0) {
+  return timestamp(transition.occurredAt || transition.time, index);
+}
+
+function edgeVisitOrder(visit, index = 0) {
+  return timestamp(visit.occurredAt || visit.time, index);
+}
+
+function visitStatus(records) {
+  if (records.some((record) => ['rejected', 'returned'].includes(record.outcome))) return 'failed';
+  if (records.some((record) => record.status === 'failed')) return 'failed';
+  if (records.some((record) => record.status === 'active')) return 'active';
+  if (records.every((record) => record.status === 'skipped')) return 'skipped';
+  if (records.some((record) => record.status === 'cancelled') && !records.some((record) => record.status === 'completed')) return 'cancelled';
+  return 'completed';
+}
+
+function statusLabel(status, records) {
+  const outcome = records.map((record) => record.outcome).filter(Boolean).at(-1);
+  if (outcome === 'rejected') return '已驳回';
+  if (outcome === 'returned') return '已退回';
+  const participants = records.map((record) => record.participant).filter((participant) => participant?.name);
+  const completed = records.filter((record) => record.status === 'completed').length;
+  const total = Math.max(records.reduce((value, record) => Math.max(value, Number(record.totalInstances) || 0), 0), records.length, participants.length);
+  const approvalMode = records.find((record) => record.approvalMode)?.approvalMode;
+  const multiInstanceMode = records.find((record) => record.multiInstanceMode)?.multiInstanceMode;
+  if (approvalMode === 'all') return `${multiInstanceMode === 'sequential' ? '顺序会签' : '会签'} ${completed}/${total}`;
+  if (approvalMode === 'any') return `或签 ${completed}/${total}`;
+  if (participants.length > 1) return `多人审批 ${completed}/${total}`;
+  return { active: '处理中', completed: '已完成', failed: '失败', cancelled: '已取消', skipped: '未经过', idle: '未到达' }[status] || status;
+}
+
+function uniqueParticipants(records) {
+  const seen = new Set();
+  return records.map((record) => record.participant).filter((participant) => {
+    if (!participant?.name) return false;
+    const key = participant.id || participant.name;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function participantSummary(participants) {
+  const visible = participants.slice(0, 2).map((participant) => participant.name).join('、');
+  return participants.length > 2 ? `${visible} +${participants.length - 2}` : visible;
+}
+
+function isStartOrEnd(node) {
+  const stage = NODE_DEFINITIONS[node?.type]?.eventStage;
+  return stage === 'start' || stage === 'end';
+}
+
+function isPlainMilestone(node, stage) {
+  const definition = NODE_DEFINITIONS[node?.type];
+  return definition?.eventStage === stage && !definition.eventDefinition;
+}
+
+function isGateway(node) {
+  return NODE_DEFINITIONS[node?.type]?.kind === 'gateway';
+}
+
+function isVisibleTraceNode(node, {
+  actual = false,
+  predicted = false,
+  showStartMilestone = false,
+  showEndMilestone = false,
+} = {}) {
+  if (!node) return false;
+  if (isPlainMilestone(node, 'start')) return showStartMilestone && (actual || predicted);
+  if (isPlainMilestone(node, 'end')) return showEndMilestone && (actual || predicted);
+  if (isStartOrEnd(node)) return actual || predicted;
+  if (EMBEDDED_SUBPROCESS_TYPES.has(node.type)) return actual || predicted;
+  if (HUMAN_TASKS.has(node.type)) return actual || predicted;
+  if (AUTOMATED_TASKS.has(node.type)) return actual;
+  return false;
+}
+
+function rootTraceElementId(model, elementId, rootNodeIds, nodeMap) {
+  if (rootNodeIds.has(elementId)) return elementId;
+  const node = nodeMap.get(elementId);
+  if (!node) return null;
+  let scopeId = node.scopeId || model.id;
+  const seen = new Set();
+  while (scopeId && scopeId !== model.id && !seen.has(scopeId)) {
+    seen.add(scopeId);
+    const owner = nodeMap.get(scopeId);
+    if (!owner || !EMBEDDED_SUBPROCESS_TYPES.has(owner.type)) return null;
+    if ((owner.scopeId || model.id) === model.id) return owner.id;
+    scopeId = owner.scopeId || model.id;
+  }
+  return null;
+}
+
+function collapseRuntimeToRoot(model, rootModel, runtime) {
+  const rootNodeIds = new Set(rootModel.nodes.map((node) => node.id));
+  const nodeMap = new Map(model.nodes.map((node) => [node.id, node]));
+  const activitySources = new Map();
+  const activityVisitSources = new Map();
+  const activities = runtime.activities.map((record) => {
+    const rootElementId = rootTraceElementId(model, record.elementId, rootNodeIds, nodeMap);
+    if (!rootElementId || rootElementId === record.elementId) return record;
+    if (!activitySources.has(rootElementId)) activitySources.set(rootElementId, new Set());
+    activitySources.get(rootElementId).add(record.elementId);
+    if (record.id && record.visitId) activityVisitSources.set(record.id, record.visitId);
+    return {
+      ...record,
+      elementId: rootElementId,
+      visitId: `subprocess:${rootElementId}`,
+      multiInstanceId: undefined,
+    };
+  });
+  const transitions = runtime.transitions.map((transition) => {
+    const sourceElementId = rootTraceElementId(model, transition.sourceElementId, rootNodeIds, nodeMap) || transition.sourceElementId;
+    const targetElementId = rootTraceElementId(model, transition.targetElementId, rootNodeIds, nodeMap) || transition.targetElementId;
+    return { ...transition, sourceElementId, targetElementId };
+  }).filter((transition) => transition.sourceElementId !== transition.targetElementId);
+  return {
+    runtime: { ...runtime, activities, transitions },
+    activitySources,
+    activityVisitSources,
+  };
+}
+
+function graphMaps(model) {
+  const nodes = new Map(model.nodes.map((node) => [node.id, node]));
+  const edges = new Map(model.edges.map((edge) => [edge.id, edge]));
+  const outgoing = new Map(model.nodes.map((node) => [node.id, []]));
+  for (const edge of model.edges) {
+    if (!outgoing.has(edge.source)) outgoing.set(edge.source, []);
+    outgoing.get(edge.source).push(edge);
+  }
+  return { nodes, edges, outgoing };
+}
+
+function findPath(outgoing, sourceId, targetId, allowed = null, maxDepth = 100) {
+  if (!sourceId || !targetId || sourceId === targetId) return [];
+  const queue = [{ id: sourceId, edges: [], seen: new Set([sourceId]) }];
+  const found = [];
+  while (queue.length && found.length < 2) {
+    const current = queue.shift();
+    if (current.edges.length >= maxDepth) continue;
+    for (const edge of outgoing.get(current.id) || []) {
+      if (allowed && !allowed.has(edge.id)) continue;
+      if (current.seen.has(edge.target)) continue;
+      const path = [...current.edges, edge];
+      if (edge.target === targetId) {
+        found.push(path);
+        continue;
+      }
+      queue.push({ id: edge.target, edges: path, seen: new Set([...current.seen, edge.target]) });
+    }
+  }
+  return found.length === 1 ? found[0] : [];
+}
+
+function inferVisitedEdges(model, runtime, outgoing) {
+  const ids = new Set([
+    ...(runtime.visitedEdges || []),
+    ...(runtime.edgeVisits || []).map((visit) => visit.edgeId),
+  ]);
+  if (ids.size) return ids;
+  const ordered = [...runtime.activities]
+    .map((record, index) => ({ record, order: recordOrder(record, index) }))
+    .sort((a, b) => a.order - b.order)
+    .map(({ record }) => record.elementId)
+    .filter((id, index, values) => id && (!index || id !== values[index - 1]));
+  for (let index = 0; index < ordered.length - 1; index += 1) {
+    for (const edge of findPath(outgoing, ordered[index], ordered[index + 1], null, model.nodes.length + 1)) ids.add(edge.id);
+  }
+  return ids;
+}
+
+function latestRuntimeElement(runtime, nodeMap) {
+  return runtime.activities
+    .map((record, index) => ({ record, order: recordOrder(record, index) }))
+    .filter(({ record }) => nodeMap.has(record.elementId) && !isGateway(nodeMap.get(record.elementId)))
+    .sort((a, b) => a.order - b.order)
+    .at(-1)?.record?.elementId || null;
+}
+
+function predictForward({ model, runtime, presentation, maps, effectiveVisited, options }) {
+  const startId = latestRuntimeElement(runtime, maps.nodes);
+  const nodeIds = new Set();
+  const edgeIds = new Set();
+  const orderedNodeIds = [];
+  if (!startId || ['completed', 'terminated'].includes(runtime.status)) return { nodeIds, edgeIds, orderedNodeIds };
+
+  const walk = (nodeId, seen, depth = 0) => {
+    if (depth > model.nodes.length * 2 || seen.has(nodeId)) return;
+    const node = maps.nodes.get(nodeId);
+    const outgoing = maps.outgoing.get(nodeId) || [];
+    if (!outgoing.length) return;
+    let candidates = outgoing.filter((edge) => effectiveVisited.has(edge.id));
+    if (!candidates.length) {
+      if (outgoing.length === 1) candidates = outgoing;
+      else if (node?.type === 'parallelGateway') candidates = outgoing;
+      else if (CONDITIONAL_GATEWAYS.has(node?.type) || isGateway(node)) return;
+      else return;
+    }
+    for (const edge of candidates) {
+      edgeIds.add(edge.id);
+      const target = maps.nodes.get(edge.target);
+      if (!target) continue;
+      if (isVisibleTraceNode(target, { predicted: true, ...options }) && !nodeIds.has(target.id)) {
+        nodeIds.add(target.id);
+        orderedNodeIds.push(target.id);
+      }
+      walk(target.id, new Set([...seen, nodeId]), depth + 1);
+    }
+  };
+  walk(startId, new Set());
+  return { nodeIds, edgeIds, orderedNodeIds };
+}
+
+function projectedEdgeId(sourceId, targetId, sourceEdges) {
+  const suffix = sourceEdges.map((edge) => edge.id).join('_').replace(/[^A-Za-z0-9_-]/g, '_');
+  return `Trace_${sourceId}_${targetId}_${suffix}`;
+}
+
+function buildProjectedGraph({ model, visibleIds, allowedEdgeIds, maps }) {
+  const graph = cloneModel(model);
+  graph.nodes = model.nodes.filter((node) => visibleIds.has(node.id)).map((node) => cloneModel(node));
+  graph.edges = [];
+  const keys = new Set();
+  for (const source of graph.nodes) {
+    const queue = (maps.outgoing.get(source.id) || [])
+      .filter((edge) => allowedEdgeIds.has(edge.id))
+      .map((edge) => ({ nodeId: edge.target, chain: [edge], seen: new Set([source.id]) }));
+    while (queue.length) {
+      const current = queue.shift();
+      if (current.seen.has(current.nodeId)) continue;
+      if (visibleIds.has(current.nodeId)) {
+        const key = `${source.id}>${current.nodeId}>${current.chain.map((edge) => edge.id).join(',')}`;
+        if (source.id !== current.nodeId && !keys.has(key)) {
+          keys.add(key);
+          const named = current.chain.find((edge) => edge.name);
+          graph.edges.push(createEdge(source.id, current.nodeId, {
+            id: projectedEdgeId(source.id, current.nodeId, current.chain),
+            name: named?.name || '',
+            condition: '',
+            sourceEdgeIds: current.chain.map((edge) => edge.id),
+          }));
+        }
+        continue;
+      }
+      for (const edge of maps.outgoing.get(current.nodeId) || []) {
+        if (!allowedEdgeIds.has(edge.id)) continue;
+        queue.push({ nodeId: edge.target, chain: [...current.chain, edge], seen: new Set([...current.seen, current.nodeId]) });
+      }
+    }
+  }
+  graph.settings = { ...(graph.settings || {}), direction: 'horizontal' };
+  if (graph.nodes.length > 1) beautify(graph, { direction: 'horizontal', density: 'balanced', edgeStyle: graph.settings.edgeStyle || 'rounded' });
+  return graph;
+}
+
+function projectRuntime(runtime, graphModel, presentation) {
+  const projectedVisited = [...runtime.visitedEdges];
+  const projectedEdgeVisits = [...runtime.edgeVisits];
+  for (const edge of graphModel.edges) {
+    const sources = edge.sourceEdgeIds || [];
+    if (!sources.length) continue;
+    const sourcePresentations = sources.map((id) => presentation.getEdge(id));
+    if (sourcePresentations.every((item) => item.historicallyVisited)) projectedVisited.push(edge.id);
+    const visits = sources.map((id) => runtime.edgeVisits
+      .filter((visit) => visit.edgeId === id)
+      .map((visit, index) => ({ visit, order: edgeVisitOrder(visit, index) }))
+      .sort((a, b) => a.order - b.order)
+      .at(-1)).filter(Boolean);
+    if (visits.length === sources.length) {
+      const latest = visits.sort((a, b) => a.order - b.order).at(-1);
+      projectedEdgeVisits.push({
+        ...latest.visit,
+        id: `TraceVisit_${edge.id}`,
+        edgeId: edge.id,
+        status: sourcePresentations.some((item) => item.superseded) ? 'superseded' : 'effective',
+      });
+    }
+  }
+  const transitions = runtime.transitions.map((transition) => ({
+    ...transition,
+    invalidatedEdgeIds: transition.invalidatedEdgeIds
+      ? [
+        ...transition.invalidatedEdgeIds,
+        ...graphModel.edges.filter((edge) => edge.sourceEdgeIds?.some((id) => transition.invalidatedEdgeIds.includes(id))).map((edge) => edge.id),
+      ]
+      : undefined,
+  }));
+  return { ...runtime, transitions, visitedEdges: [...new Set(projectedVisited)], edgeVisits: projectedEdgeVisits };
+}
+
+function buildVisitItems(model, runtime, presentation, predictedNodeIds, orderedPredictedIds, options) {
+  const nodeMap = new Map(model.nodes.map((node) => [node.id, node]));
+  const transitionActionIds = new Set(presentation.getTransitions().map((transition) => transition.actionId).filter(Boolean));
+  const groups = new Map();
+  runtime.activities.forEach((record, index) => {
+    const node = nodeMap.get(record.elementId);
+    if (!node || isGateway(node) || !isVisibleTraceNode(node, { actual: true, ...options })) return;
+    const visitKey = record.visitId || record.multiInstanceId || record.id || String(index);
+    const key = `${record.elementId}:${visitKey}`;
+    if (!groups.has(key)) groups.set(key, { key, node, visitId: visitKey, records: [], order: recordOrder(record, index), originalIndex: index });
+    const group = groups.get(key);
+    group.records.push(record);
+    group.order = Math.min(group.order, recordOrder(record, index));
+  });
+  const rounds = new Map();
+  const items = [...groups.values()].sort((a, b) => (a.order - b.order) || (a.originalIndex - b.originalIndex)).map((group) => {
+    const round = (rounds.get(group.node.id) || 0) + 1;
+    rounds.set(group.node.id, round);
+    const status = visitStatus(group.records);
+    const participants = uniqueParticipants(group.records);
+    const startTime = group.records.map((record) => record.startTime).filter(Boolean).sort()[0];
+    const endTime = group.records.map((record) => record.endTime).filter(Boolean).sort().at(-1);
+    const actions = (presentation.getNode(group.node.id).visits.find((visit) => visit.id === group.visitId)?.actions || [])
+      .filter((action) => !transitionActionIds.has(action.id));
+    const latestAction = [...actions].reverse().find((action) => action.plainText || action.assetCount) || actions.at(-1) || null;
+    const imageCount = actions.reduce((sum, action) => sum + action.imageCount, 0);
+    const fileCount = actions.reduce((sum, action) => sum + action.fileCount, 0);
+    const assetSummary = latestAction
+      ? [latestAction.imageCount ? `${latestAction.imageCount} 张图片` : '', latestAction.fileCount ? `${latestAction.fileCount} 个附件` : ''].filter(Boolean).join(' · ')
+      : '';
+    return {
+      id: `TraceItem_${group.node.id}_${group.visitId}`,
+      kind: isStartOrEnd(group.node) ? 'milestone' : 'activity',
+      elementId: group.node.id,
+      visitId: group.visitId,
+      round,
+      name: group.node.name || NODE_DEFINITIONS[group.node.type]?.label || group.node.id,
+      nodeType: group.node.type,
+      automated: AUTOMATED_TASKS.has(group.node.type),
+      status,
+      statusLabel: statusLabel(status, group.records),
+      participants,
+      summary: participantSummary(participants) || presentation.getNode(group.node.id).summary,
+      records: group.records,
+      actions,
+      latestAction,
+      actionText: latestAction?.plainText || '',
+      actionSummary: latestAction ? [latestAction.label, latestAction.plainText, assetSummary].filter(Boolean).join(' · ') : '',
+      imageCount,
+      fileCount,
+      assetCount: imageCount + fileCount,
+      startTime,
+      endTime,
+      time: endTime || startTime || '',
+      outcome: group.records.map((record) => record.outcome).filter(Boolean).at(-1) || '',
+      comment: latestAction?.plainText || group.records.map((record) => record.comment).filter(Boolean).at(-1) || '',
+      predicted: false,
+      order: group.order,
+    };
+  });
+  let predictedOrder = Math.max(0, ...items.map((item) => item.order)) + 1;
+  for (const nodeId of orderedPredictedIds) {
+    if (!predictedNodeIds.has(nodeId) || items.some((item) => item.elementId === nodeId)) continue;
+    const node = nodeMap.get(nodeId);
+    if (!isVisibleTraceNode(node, { predicted: true, ...options })) continue;
+    items.push({
+      id: `TraceItem_Predicted_${node.id}`,
+      kind: isStartOrEnd(node) ? 'milestone' : 'activity',
+      elementId: node.id,
+      visitId: null,
+      round: 0,
+      name: node.name || NODE_DEFINITIONS[node.type]?.label || node.id,
+      nodeType: node.type,
+      automated: false,
+      status: 'idle',
+      statusLabel: '未到达',
+      participants: [],
+      summary: '待处理',
+      records: [],
+      actions: [],
+      latestAction: null,
+      actionText: '',
+      actionSummary: '',
+      imageCount: 0,
+      fileCount: 0,
+      assetCount: 0,
+      startTime: '',
+      endTime: '',
+      time: '',
+      outcome: '',
+      comment: '',
+      predicted: true,
+      order: predictedOrder++,
+    });
+  }
+  for (const transition of presentation.getTransitions().filter((item) => ABNORMAL_TRANSITIONS.has(item.type))) {
+    items.push({
+      id: `TraceTransition_${transition.id}`,
+      kind: 'transition',
+      transitionId: transition.id,
+      type: transition.type,
+      name: transition.label,
+      status: transition.state,
+      statusLabel: transition.type === 'reject' ? '驳回' : '退回',
+      summary: transition.operator || '',
+      time: transition.occurredAt || transition.time || '',
+      comment: transition.action?.plainText || transition.comment || '',
+      actions: transition.action ? [transition.action] : [],
+      latestAction: transition.action || null,
+      actionText: transition.action?.plainText || '',
+      actionSummary: transition.action ? [transition.action.label, transition.action.plainText].filter(Boolean).join(' · ') : '',
+      imageCount: transition.action?.imageCount || 0,
+      fileCount: transition.action?.fileCount || 0,
+      assetCount: transition.action?.assetCount || 0,
+      sourceElementId: transition.sourceElementId,
+      targetElementId: transition.targetElementId,
+      predicted: false,
+      order: transitionOrder(transition, 0),
+    });
+  }
+  return items.sort((a, b) => (a.order - b.order) || a.id.localeCompare(b.id));
+}
+
+function buildTimelineLinks(items, maps, historicalEdgeIds, allowedEdgeIds) {
+  const links = [];
+  const traceActivities = items.filter((item) => item.kind !== 'transition');
+  for (let index = 0; index < traceActivities.length - 1; index += 1) {
+    const source = traceActivities[index];
+    const target = traceActivities[index + 1];
+    if (source.elementId === target.elementId) continue;
+    const allowed = source.predicted || target.predicted ? allowedEdgeIds : historicalEdgeIds;
+    const path = findPath(maps.outgoing, source.elementId, target.elementId, allowed, maps.nodes.size + 1);
+    if (!path.length) continue;
+    links.push({
+      id: `TraceLink_${source.id}_${target.id}`,
+      sourceItemId: source.id,
+      targetItemId: target.id,
+      sourceElementId: source.elementId,
+      targetElementId: target.elementId,
+      sourceEdgeIds: path.map((edge) => edge.id),
+      label: path.find((edge) => edge.name)?.name || '',
+      predicted: source.predicted || target.predicted,
+    });
+  }
+  return links;
+}
+
+function firstVisibleFrom(edge, maps, visibleElementIds, allowedEdgeIds) {
+  const queue = [edge.target];
+  const seen = new Set();
+  while (queue.length) {
+    const nodeId = queue.shift();
+    if (seen.has(nodeId)) continue;
+    seen.add(nodeId);
+    if (visibleElementIds.has(nodeId)) return nodeId;
+    for (const next of maps.outgoing.get(nodeId) || []) if (allowedEdgeIds.has(next.id)) queue.push(next.target);
+  }
+  return null;
+}
+
+function buildParallelGroups(model, items, maps, allowedEdgeIds) {
+  const itemByElement = new Map();
+  for (const item of items.filter((entry) => entry.kind !== 'transition')) {
+    if (!itemByElement.has(item.elementId) || item.predicted) itemByElement.set(item.elementId, item);
+  }
+  const visibleElementIds = new Set(itemByElement.keys());
+  const groups = [];
+  for (const gateway of model.nodes.filter((node) => node.type === 'parallelGateway')) {
+    const outgoing = (maps.outgoing.get(gateway.id) || []).filter((edge) => allowedEdgeIds.has(edge.id));
+    if (outgoing.length < 2) continue;
+    const itemIds = [...new Set(outgoing.map((edge) => firstVisibleFrom(edge, maps, visibleElementIds, allowedEdgeIds)).filter(Boolean).map((id) => itemByElement.get(id)?.id).filter(Boolean))];
+    if (itemIds.length < 2) continue;
+    const children = itemIds.map((id) => items.find((item) => item.id === id));
+    groups.push({
+      id: `TraceGroup_${gateway.id}`,
+      kind: 'parallel',
+      gatewayId: gateway.id,
+      label: gateway.name || '并行审批',
+      itemIds,
+      completed: children.filter((item) => item.status === 'completed').length,
+      total: children.length,
+      status: children.some((item) => item.status === 'active') ? 'active' : children.every((item) => item.status === 'completed') ? 'completed' : 'idle',
+      order: Math.min(...children.map((item) => item.order)),
+    });
+  }
+  return groups;
+}
+
+export function createRuntimeTraceProjection({ model, runtime, presentation, options = {} } = {}) {
+  if (!model) throw new Error('createRuntimeTraceProjection requires model.');
+  const rootModel = getScopeGraph(model, model.id);
+  const normalizedSource = normalizeRuntime(runtime);
+  const collapsed = collapseRuntimeToRoot(model, rootModel, normalizedSource);
+  const normalized = collapsed.runtime;
+  const hasCollapsedActivities = collapsed.activitySources.size > 0;
+  const runtimePresentation = !hasCollapsedActivities && presentation
+    ? presentation
+    : createRuntimePresentation({ model: rootModel, runtime: normalized });
+  const maps = graphMaps(rootModel);
+  const historicalEdgeIds = inferVisitedEdges(rootModel, normalized, maps.outgoing);
+  const effectiveVisited = new Set([...historicalEdgeIds].filter((edgeId) => !runtimePresentation.getEdge(edgeId).superseded));
+  const prediction = options.includePredicted === false
+    ? { nodeIds: new Set(), edgeIds: new Set(), orderedNodeIds: [] }
+    : predictForward({ model: rootModel, runtime: normalized, presentation: runtimePresentation, maps, effectiveVisited, options });
+  const allowedEdgeIds = new Set([...historicalEdgeIds, ...prediction.edgeIds]);
+  const actualNodeIds = new Set(normalized.activities.map((record) => record.elementId));
+  for (const edgeId of historicalEdgeIds) {
+    const edge = maps.edges.get(edgeId);
+    if (!edge) continue;
+    if (isStartOrEnd(maps.nodes.get(edge.source))) actualNodeIds.add(edge.source);
+    if (isStartOrEnd(maps.nodes.get(edge.target))) actualNodeIds.add(edge.target);
+  }
+  const visibleIds = new Set(rootModel.nodes.filter((node) => isVisibleTraceNode(node, {
+    actual: actualNodeIds.has(node.id),
+    predicted: prediction.nodeIds.has(node.id),
+    ...options,
+  })).map((node) => node.id));
+  const graphModel = buildProjectedGraph({ model: rootModel, visibleIds, allowedEdgeIds, maps });
+  const graphRuntime = projectRuntime(normalized, graphModel, runtimePresentation);
+  const items = buildVisitItems(rootModel, normalized, runtimePresentation, prediction.nodeIds, prediction.orderedNodeIds, options);
+  const links = buildTimelineLinks(items, maps, historicalEdgeIds, allowedEdgeIds);
+  const groups = buildParallelGroups(rootModel, items, maps, allowedEdgeIds);
+  const warnings = [];
+  for (const record of normalizedSource.activities) {
+    if (!model.nodes.some((node) => node.id === record.elementId)) warnings.push(`运行记录引用了不存在的元素：${record.elementId}`);
+  }
+  const nodeMappings = Object.fromEntries(graphModel.nodes.map((node) => [
+    node.id,
+    [node.id, ...(collapsed.activitySources.get(node.id) || [])],
+  ]));
+  const edgeMappings = Object.fromEntries(graphModel.edges.map((edge) => [edge.id, edge.sourceEdgeIds || [edge.id]]));
+  const itemMappings = Object.fromEntries(items.map((item) => [item.id, {
+    elementIds: item.kind === 'transition'
+      ? [item.sourceElementId, item.targetElementId].filter(Boolean)
+      : [item.elementId, ...(collapsed.activitySources.get(item.elementId) || [])].filter(Boolean),
+    activityIds: (item.records || []).map((record) => record.id).filter(Boolean),
+    visitIds: [...new Set((item.records || []).map((record) => collapsed.activityVisitSources.get(record.id) || record.visitId).filter(Boolean))],
+  }]));
+  const edgeVisitMappings = Object.fromEntries(graphModel.edges.map((edge) => [
+    edge.id,
+    normalizedSource.edgeVisits.filter((visit) => (edge.sourceEdgeIds || [edge.id]).includes(visit.edgeId)).map((visit) => visit.id).filter(Boolean),
+  ]));
+  return {
+    graphModel,
+    graphRuntime,
+    items,
+    links,
+    groups,
+    warnings,
+    mappings: {
+      nodes: nodeMappings,
+      edges: edgeMappings,
+      items: itemMappings,
+      edgeVisits: edgeVisitMappings,
+    },
+  };
+}