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

package/dist/modules/core/containment.js

@@ -0,0 +1,590 @@
+import { NODE_DEFINITIONS } from './model.js';
+
+export const CONTAINMENT_LIMITS = Object.freeze({
+  groupMinWidth: 120,
+  groupMinHeight: 80,
+  groupPadding: 28,
+  participantMinWidth: 320,
+  participantMinHeight: 120,
+  laneMinWidth: 240,
+  laneMinHeight: 72,
+  swimlaneTitleSize: 38,
+  participantRailWidth: 38,
+  participantContentPadding: 24,
+});
+
+export const SWIMLANE_LABEL_PLACEMENTS = Object.freeze({
+  side: 'side',
+  top: 'top',
+});
+
+const SWIMLANE_LABEL_PLACEMENT_VALUES = new Set(Object.values(SWIMLANE_LABEL_PLACEMENTS));
+
+const FLOW_NODE_KINDS = new Set(['event', 'boundary', 'task', 'container', 'gateway']);
+
+function kindOf(node) {
+  return NODE_DEFINITIONS[node?.type]?.kind;
+}
+
+function normalizeSwimlaneLabelPlacement(value) {
+  return SWIMLANE_LABEL_PLACEMENT_VALUES.has(value) ? value : SWIMLANE_LABEL_PLACEMENTS.side;
+}
+
+function insetsForSwimlaneLabelPlacement(placement) {
+  const size = CONTAINMENT_LIMITS.swimlaneTitleSize;
+  return normalizeSwimlaneLabelPlacement(placement) === SWIMLANE_LABEL_PLACEMENTS.top
+    ? { top: size, right: 0, bottom: 0, left: 0 }
+    : { top: 0, right: 0, bottom: 0, left: size };
+}
+
+export function resolveSwimlaneLabelPlacement(model, node) {
+  if (!node || !['participant', 'lane'].includes(kindOf(node))) return SWIMLANE_LABEL_PLACEMENTS.side;
+  let source = node;
+  if (kindOf(node) === 'lane' && node.containerId) {
+    const participant = model?.nodes?.find((candidate) => candidate.id === node.containerId && kindOf(candidate) === 'participant');
+    if (participant) source = participant;
+  }
+  return normalizeSwimlaneLabelPlacement(source.properties?.swimlaneLabelPlacement);
+}
+
+export function getSwimlaneContentInsets(model, node) {
+  return insetsForSwimlaneLabelPlacement(resolveSwimlaneLabelPlacement(model, node));
+}
+
+export function getSwimlaneContentBounds(model, node) {
+  const insets = getSwimlaneContentInsets(model, node);
+  return {
+    x: node.x + insets.left,
+    y: node.y + insets.top,
+    width: Math.max(0, node.width - insets.left - insets.right),
+    height: Math.max(0, node.height - insets.top - insets.bottom),
+  };
+}
+
+function isFlowNode(node) {
+  return FLOW_NODE_KINDS.has(kindOf(node));
+}
+
+function center(node) {
+  return { x: node.x + node.width / 2, y: node.y + node.height / 2 };
+}
+
+function containsPoint(node, point, inset = 0) {
+  return point.x >= node.x + inset
+    && point.x <= node.x + node.width - inset
+    && point.y >= node.y + inset
+    && point.y <= node.y + node.height - inset;
+}
+
+function laneReferences(lane) {
+  return Array.isArray(lane?.properties?.flowNodeRefs) ? lane.properties.flowNodeRefs : [];
+}
+
+function setLaneReferences(lane, refs) {
+  lane.properties = { ...(lane.properties || {}), flowNodeRefs: [...new Set(refs)] };
+}
+
+function isCurrentProcessParticipant(model, node) {
+  return kindOf(node) === 'participant'
+    && (node.scopeId || model.id) === model.id
+    && node.properties?.processRef === model.id;
+}
+
+function participantLanes(model, participantId) {
+  return model.nodes
+    .filter((node) => kindOf(node) === 'lane' && node.containerId === participantId)
+    .sort((a, b) => a.y - b.y || a.x - b.x || a.id.localeCompare(b.id));
+}
+
+function memberIdsForLane(model, lane) {
+  const ids = new Set(laneReferences(lane));
+  for (const node of model.nodes) {
+    if (kindOf(node) !== 'boundary') continue;
+    if (ids.has(node.properties?.attachedToRef)) ids.add(node.id);
+  }
+  return ids;
+}
+
+function minimumLaneHeight(model, lane) {
+  const insets = getSwimlaneContentInsets(model, lane);
+  return CONTAINMENT_LIMITS.laneMinHeight + insets.top + insets.bottom;
+}
+
+function minimumParticipantHeight(model, participant, lanes = participantLanes(model, participant.id)) {
+  const insets = getSwimlaneContentInsets(model, participant);
+  const lanesHeight = lanes.reduce((sum, lane) => sum + minimumLaneHeight(model, lane), 0);
+  return Math.max(
+    CONTAINMENT_LIMITS.participantMinHeight,
+    insets.top + insets.bottom + lanesHeight,
+  );
+}
+
+function contentOriginForPlacement(node, placement) {
+  const insets = insetsForSwimlaneLabelPlacement(placement);
+  return { x: node.x + insets.left, y: node.y + insets.top };
+}
+
+function translateLaneMembersForPlacementChange(model, lane, previousPlacement) {
+  const nextPlacement = resolveSwimlaneLabelPlacement(model, lane);
+  if (nextPlacement === normalizeSwimlaneLabelPlacement(previousPlacement)) return;
+  const previousInsets = insetsForSwimlaneLabelPlacement(previousPlacement);
+  const nextInsets = insetsForSwimlaneLabelPlacement(nextPlacement);
+  translateNodes(
+    model,
+    memberIdsForLane(model, lane),
+    nextInsets.left - previousInsets.left,
+    nextInsets.top - previousInsets.top,
+  );
+}
+
+function translateNodes(model, ids, dx, dy) {
+  if (!dx && !dy) return;
+  for (const node of model.nodes) {
+    if (!ids.has(node.id)) continue;
+    node.x += dx;
+    node.y += dy;
+  }
+}
+
+function layoutParticipantLanes(model, participant, lanes, options = {}) {
+  if (!lanes.length) return;
+  const insets = getSwimlaneContentInsets(model, participant);
+  const previous = new Map(lanes.map((lane) => [lane.id, { x: lane.x, y: lane.y }]));
+  const total = lanes.reduce((sum, lane) => sum + Math.max(minimumLaneHeight(model, lane), lane.height), 0);
+  const contentHeight = Math.max(0, participant.height - insets.top - insets.bottom);
+  if (total < contentHeight) {
+    lanes[lanes.length - 1].height = Math.max(
+      minimumLaneHeight(model, lanes[lanes.length - 1]),
+      lanes[lanes.length - 1].height + contentHeight - total,
+    );
+  } else if (total > contentHeight) {
+    participant.height = Math.max(
+      minimumParticipantHeight(model, participant, lanes),
+      insets.top + total + insets.bottom,
+    );
+  }
+
+  let y = participant.y + insets.top;
+  for (const lane of lanes) {
+    lane.height = Math.max(minimumLaneHeight(model, lane), lane.height);
+    lane.x = participant.x + insets.left;
+    lane.y = y;
+    lane.width = Math.max(1, participant.width - insets.left - insets.right);
+    y += lane.height;
+  }
+  participant.height = Math.max(
+    minimumParticipantHeight(model, participant, lanes),
+    y - participant.y + insets.bottom,
+  );
+
+  if (options.moveMembers !== false) {
+    for (const lane of lanes) {
+      const before = previous.get(lane.id);
+      if (!before) continue;
+      translateNodes(model, memberIdsForLane(model, lane), lane.x - before.x, lane.y - before.y);
+    }
+  }
+}
+
+function eligibleParticipantAt(model, point) {
+  return model.nodes
+    .filter((node) => isCurrentProcessParticipant(model, node))
+    .filter((node) => containsPoint(node, point))
+    .sort((a, b) => a.width * a.height - b.width * b.height)[0] || null;
+}
+
+function laneAt(model, point, excludedId = '', scopeId = null) {
+  return model.nodes
+    .filter((node) => kindOf(node) === 'lane' && node.id !== excludedId)
+    .filter((node) => scopeId === null || (node.scopeId || model.id) === scopeId)
+    .filter((node) => containsPoint(node, point))
+    .sort((a, b) => a.width * a.height - b.width * b.height)[0] || null;
+}
+
+function removeNodeFromLanes(model, nodeId) {
+  let changed = false;
+  for (const lane of model.nodes.filter((node) => kindOf(node) === 'lane')) {
+    const refs = laneReferences(lane);
+    const next = refs.filter((id) => id !== nodeId);
+    if (next.length !== refs.length) {
+      setLaneReferences(lane, next);
+      changed = true;
+    }
+  }
+  return changed;
+}
+
+function assignNodeToLane(model, nodeId) {
+  const node = model.nodes.find((candidate) => candidate.id === nodeId);
+  if (!node || !isFlowNode(node)) return false;
+  const inheritedHostId = kindOf(node) === 'boundary' ? node.properties?.attachedToRef : '';
+  const lookupId = inheritedHostId || nodeId;
+  const lookupNode = model.nodes.find((candidate) => candidate.id === lookupId) || node;
+  const target = laneAt(model, center(lookupNode), '', lookupNode.scopeId || model.id);
+  let changed = removeNodeFromLanes(model, nodeId);
+  if (!target) return changed;
+  const refs = laneReferences(target);
+  if (!refs.includes(nodeId)) {
+    setLaneReferences(target, [...refs, nodeId]);
+    changed = true;
+  }
+  return changed;
+}
+
+function reconcile(model, options = {}) {
+  const nodeIds = new Set(model.nodes.map((node) => node.id));
+  const participants = new Map(
+    model.nodes.filter((node) => isCurrentProcessParticipant(model, node)).map((node) => [node.id, node]),
+  );
+  let changed = false;
+
+  for (const lane of model.nodes.filter((node) => kindOf(node) === 'lane')) {
+    if (lane.containerId && !participants.has(lane.containerId)) {
+      delete lane.containerId;
+      changed = true;
+    }
+    if (!lane.containerId && options.inferOwners) {
+      const owner = eligibleParticipantAt(model, center(lane));
+      if (owner) {
+        lane.containerId = owner.id;
+        changed = true;
+      }
+    }
+    const refs = laneReferences(lane);
+    const laneScopeId = lane.scopeId || model.id;
+    const next = refs.filter((id) => {
+      const referenced = model.nodes.find((node) => node.id === id);
+      return nodeIds.has(id) && isFlowNode(referenced) && (referenced.scopeId || model.id) === laneScopeId;
+    });
+    if (next.length !== refs.length || new Set(next).size !== next.length) {
+      setLaneReferences(lane, next);
+      changed = true;
+    }
+  }
+
+  const claimed = new Set();
+  for (const lane of model.nodes.filter((node) => kindOf(node) === 'lane')) {
+    const next = laneReferences(lane).filter((id) => {
+      if (claimed.has(id)) return false;
+      claimed.add(id);
+      return true;
+    });
+    if (next.length !== laneReferences(lane).length) {
+      setLaneReferences(lane, next);
+      changed = true;
+    }
+  }
+
+  for (const boundary of model.nodes.filter((node) => kindOf(node) === 'boundary')) {
+    const hostId = boundary.properties?.attachedToRef;
+    if (!hostId) continue;
+    const ownerLane = model.nodes.find((lane) => kindOf(lane) === 'lane' && laneReferences(lane).includes(hostId));
+    const currentLane = model.nodes.find((lane) => kindOf(lane) === 'lane' && laneReferences(lane).includes(boundary.id));
+    if (currentLane?.id !== ownerLane?.id) {
+      removeNodeFromLanes(model, boundary.id);
+      if (ownerLane) setLaneReferences(ownerLane, [...laneReferences(ownerLane), boundary.id]);
+      changed = true;
+    }
+  }
+
+  if (options.normalize) {
+    for (const participant of participants.values()) {
+      const lanes = participantLanes(model, participant.id);
+      if (lanes.length) layoutParticipantLanes(model, participant, lanes, { moveMembers: false });
+    }
+  }
+  return changed;
+}
+
+function attachLane(model, lane, participant, index) {
+  if (!lane
+    || kindOf(lane) !== 'lane'
+    || (lane.scopeId || model.id) !== model.id
+    || !isCurrentProcessParticipant(model, participant)) return false;
+  let previousPlacement = resolveSwimlaneLabelPlacement(model, lane);
+  if (lane.containerId === participant.id) {
+    const lanes = participantLanes(model, participant.id).filter((candidate) => candidate.id !== lane.id);
+    const nextIndex = Math.max(0, Math.min(index ?? lanes.length, lanes.length));
+    lanes.splice(nextIndex, 0, lane);
+    layoutParticipantLanes(model, participant, lanes);
+    translateLaneMembersForPlacementChange(model, lane, previousPlacement);
+    return true;
+  }
+
+  if (lane.containerId) {
+    detachLane(model, lane, { preservePosition: true });
+    previousPlacement = resolveSwimlaneLabelPlacement(model, lane);
+  }
+  const existing = participantLanes(model, participant.id);
+  lane.containerId = participant.id;
+  if (!existing.length) {
+    const content = getSwimlaneContentBounds(model, participant);
+    lane.height = Math.max(minimumLaneHeight(model, lane), content.height);
+    layoutParticipantLanes(model, participant, [lane]);
+    translateLaneMembersForPlacementChange(model, lane, previousPlacement);
+    return true;
+  }
+
+  lane.height = Math.max(minimumLaneHeight(model, lane), lane.height);
+  const nextIndex = Math.max(0, Math.min(index ?? existing.length, existing.length));
+  existing.splice(nextIndex, 0, lane);
+  participant.height += lane.height;
+  layoutParticipantLanes(model, participant, existing);
+  translateLaneMembersForPlacementChange(model, lane, previousPlacement);
+  return true;
+}
+
+function detachLane(model, lane, options = {}) {
+  if (!lane?.containerId) return false;
+  const previousPlacement = resolveSwimlaneLabelPlacement(model, lane);
+  const participant = model.nodes.find((node) => node.id === lane.containerId && kindOf(node) === 'participant');
+  const detachedHeight = lane.height;
+  delete lane.containerId;
+  if (participant) {
+    const remaining = participantLanes(model, participant.id);
+    if (remaining.length) {
+      participant.height = Math.max(minimumParticipantHeight(model, participant, remaining), participant.height - detachedHeight);
+      layoutParticipantLanes(model, participant, remaining);
+    }
+  }
+  lane.width = Math.max(CONTAINMENT_LIMITS.laneMinWidth, lane.width);
+  lane.height = Math.max(minimumLaneHeight(model, lane), lane.height);
+  if (!options.preservePosition && Number.isFinite(options.x) && Number.isFinite(options.y)) {
+    const dx = options.x - lane.x;
+    const dy = options.y - lane.y;
+    lane.x = options.x;
+    lane.y = options.y;
+    translateNodes(model, memberIdsForLane(model, lane), dx, dy);
+  }
+  translateLaneMembersForPlacementChange(model, lane, previousPlacement);
+  return true;
+}
+
+function moveContainer(model, node, dx, dy) {
+  if (!node || (!dx && !dy)) return false;
+  const ids = new Set([node.id]);
+  if (kindOf(node) === 'participant') {
+    const lanes = participantLanes(model, node.id);
+    for (const lane of lanes) {
+      ids.add(lane.id);
+      for (const memberId of memberIdsForLane(model, lane)) ids.add(memberId);
+    }
+  } else if (kindOf(node) === 'lane') {
+    for (const memberId of memberIdsForLane(model, node)) ids.add(memberId);
+  }
+  translateNodes(model, ids, dx, dy);
+  return true;
+}
+
+function memberCenters(model, lanes) {
+  const ids = new Set(lanes.flatMap((lane) => [...memberIdsForLane(model, lane)]));
+  return model.nodes.filter((node) => ids.has(node.id)).map(center);
+}
+
+function resizeParticipant(model, participant, requested) {
+  const old = { x: participant.x, y: participant.y, width: participant.width, height: participant.height };
+  const lanes = participantLanes(model, participant.id);
+  const points = memberCenters(model, lanes);
+  const participantInsets = getSwimlaneContentInsets(model, participant);
+  const laneInsets = lanes[0] ? getSwimlaneContentInsets(model, lanes[0]) : { top: 0, right: 0, bottom: 0, left: 0 };
+  const padding = CONTAINMENT_LIMITS.participantContentPadding;
+  const minLaneHeight = lanes.reduce((sum, lane) => sum + minimumLaneHeight(model, lane), 0);
+  let left = requested.x;
+  let top = requested.y;
+  let right = requested.x + requested.width;
+  let bottom = requested.y + requested.height;
+
+  if (points.length) {
+    const minX = Math.min(...points.map((point) => point.x));
+    const maxX = Math.max(...points.map((point) => point.x));
+    const minY = Math.min(...points.map((point) => point.y));
+    const maxY = Math.max(...points.map((point) => point.y));
+    left = Math.min(left, minX - participantInsets.left - laneInsets.left - padding);
+    right = Math.max(right, maxX + participantInsets.right + laneInsets.right + padding);
+    top = Math.min(top, minY - participantInsets.top - laneInsets.top - padding);
+    bottom = Math.max(bottom, maxY + participantInsets.bottom + laneInsets.bottom + padding);
+  }
+
+  const minWidth = CONTAINMENT_LIMITS.participantMinWidth;
+  const minHeight = Math.max(
+    CONTAINMENT_LIMITS.participantMinHeight,
+    participantInsets.top + minLaneHeight + participantInsets.bottom,
+  );
+  if (right - left < minWidth) right = left + minWidth;
+  if (bottom - top < minHeight) bottom = top + minHeight;
+  participant.x = left;
+  participant.y = top;
+  participant.width = right - left;
+  participant.height = bottom - top;
+
+  if (lanes.length) {
+    const topDelta = top - old.y;
+    const bottomDelta = bottom - (old.y + old.height);
+    lanes[0].height = Math.max(minimumLaneHeight(model, lanes[0]), lanes[0].height - topDelta);
+    lanes[lanes.length - 1].height = Math.max(
+      minimumLaneHeight(model, lanes[lanes.length - 1]),
+      lanes[lanes.length - 1].height + bottomDelta,
+    );
+    const laneHeight = lanes.reduce((sum, lane) => sum + lane.height, 0);
+    const contentHeight = participant.height - participantInsets.top - participantInsets.bottom;
+    const resizingFromTop = Math.abs(bottom - (old.y + old.height)) < 0.5 && Math.abs(top - old.y) >= 0.5;
+    if (laneHeight > contentHeight && resizingFromTop) {
+      participant.height = laneHeight + participantInsets.top + participantInsets.bottom;
+      participant.y = bottom - participant.height;
+    }
+    layoutParticipantLanes(model, participant, lanes, { moveMembers: false });
+  }
+  return true;
+}
+
+function resizeNode(model, node, requested) {
+  if (!node || !requested) return false;
+  const kind = kindOf(node);
+  if (kind === 'participant') return resizeParticipant(model, node, requested);
+  if (kind === 'lane' && node.containerId) return false;
+  const minimum = kind === 'group'
+    ? { width: CONTAINMENT_LIMITS.groupMinWidth, height: CONTAINMENT_LIMITS.groupMinHeight }
+    : kind === 'lane'
+      ? { width: CONTAINMENT_LIMITS.laneMinWidth, height: minimumLaneHeight(model, node) }
+      : null;
+  if (!minimum) return false;
+  node.x = requested.x;
+  node.y = requested.y;
+  node.width = Math.max(minimum.width, requested.width);
+  node.height = Math.max(minimum.height, requested.height);
+  return true;
+}
+
+function resizeDivider(model, lane, delta) {
+  if (!lane?.containerId || !delta) return false;
+  const participant = model.nodes.find((node) => node.id === lane.containerId);
+  const lanes = participant ? participantLanes(model, participant.id) : [];
+  const index = lanes.findIndex((candidate) => candidate.id === lane.id);
+  if (index < 0 || index === lanes.length - 1) return false;
+  const upper = lanes[index];
+  const lower = lanes[index + 1];
+  const upperMinimum = minimumLaneHeight(model, upper);
+  const lowerMinimum = minimumLaneHeight(model, lower);
+  const clamped = Math.max(
+    upperMinimum - upper.height,
+    Math.min(delta, lower.height - lowerMinimum),
+  );
+  if (!clamped) return false;
+  upper.height += clamped;
+  lower.height -= clamped;
+  layoutParticipantLanes(model, participant, lanes);
+  return true;
+}
+
+function updateLabelPlacement(model, node, previousPlacement) {
+  const kind = kindOf(node);
+  const previous = normalizeSwimlaneLabelPlacement(previousPlacement);
+  const next = resolveSwimlaneLabelPlacement(model, node);
+  if (!['participant', 'lane'].includes(kind) || previous === next) return false;
+  if (kind === 'lane' && node.containerId) return false;
+
+  if (kind === 'lane') {
+    const previousOrigin = contentOriginForPlacement(node, previous);
+    const previousInsets = insetsForSwimlaneLabelPlacement(previous);
+    const nextInsets = insetsForSwimlaneLabelPlacement(next);
+    node.height = Math.max(
+      minimumLaneHeight(model, node),
+      node.height + nextInsets.top + nextInsets.bottom - previousInsets.top - previousInsets.bottom,
+    );
+    const nextOrigin = contentOriginForPlacement(node, next);
+    translateNodes(model, memberIdsForLane(model, node), nextOrigin.x - previousOrigin.x, nextOrigin.y - previousOrigin.y);
+    return true;
+  }
+
+  const lanes = participantLanes(model, node.id);
+  const previousOrigins = new Map(lanes.map((lane) => [lane.id, contentOriginForPlacement(lane, previous)]));
+  const previousInsets = insetsForSwimlaneLabelPlacement(previous);
+  const nextInsets = insetsForSwimlaneLabelPlacement(next);
+  const laneHeightDelta = nextInsets.top + nextInsets.bottom - previousInsets.top - previousInsets.bottom;
+  let totalLaneHeightDelta = 0;
+  for (const lane of lanes) {
+    const before = lane.height;
+    lane.height = Math.max(minimumLaneHeight(model, lane), lane.height + laneHeightDelta);
+    totalLaneHeightDelta += lane.height - before;
+  }
+  node.height = Math.max(
+    minimumParticipantHeight(model, node, lanes),
+    node.height + nextInsets.top + nextInsets.bottom - previousInsets.top - previousInsets.bottom + totalLaneHeightDelta,
+  );
+  if (!lanes.length) return true;
+
+  layoutParticipantLanes(model, node, lanes, { moveMembers: false });
+  for (const lane of lanes) {
+    const before = previousOrigins.get(lane.id);
+    const after = contentOriginForPlacement(lane, next);
+    translateNodes(model, memberIdsForLane(model, lane), after.x - before.x, after.y - before.y);
+  }
+  return true;
+}
+
+export function resolveContainment(model) {
+  const nodesById = new Map((model?.nodes || []).map((node) => [node.id, node]));
+  const lanesByParticipant = new Map();
+  const laneByNode = new Map();
+  for (const node of model?.nodes || []) {
+    if (kindOf(node) !== 'lane') continue;
+    if (node.containerId) {
+      const lanes = lanesByParticipant.get(node.containerId) || [];
+      lanes.push(node);
+      lanesByParticipant.set(node.containerId, lanes);
+    }
+    for (const ref of laneReferences(node)) if (!laneByNode.has(ref)) laneByNode.set(ref, node);
+  }
+  for (const lanes of lanesByParticipant.values()) lanes.sort((a, b) => a.y - b.y || a.id.localeCompare(b.id));
+  return {
+    nodesById,
+    lanesByParticipant,
+    laneByNode,
+    getParticipantLanes: (participantId) => lanesByParticipant.get(participantId) || [],
+    getLaneForNode: (nodeId) => laneByNode.get(nodeId) || null,
+    getLaneAt: (point, excludedId) => laneAt(model, point, excludedId),
+    getParticipantAt: (point) => eligibleParticipantAt(model, point),
+  };
+}
+
+export function applyContainmentOperation(model, operation = {}) {
+  if (!model?.nodes || !operation.type) return { changed: false };
+  const node = model.nodes.find((candidate) => candidate.id === (operation.nodeId || operation.laneId));
+  let changed = false;
+  if (operation.type === 'reconcile') {
+    changed = reconcile(model, operation);
+  } else if (operation.type === 'attach-lane') {
+    const participant = model.nodes.find((candidate) => candidate.id === operation.participantId);
+    changed = attachLane(model, node, participant, operation.index);
+    if (changed) {
+      for (const candidate of model.nodes) if (isFlowNode(candidate)) assignNodeToLane(model, candidate.id);
+      reconcile(model);
+    }
+  } else if (operation.type === 'detach-lane') {
+    changed = detachLane(model, node, operation);
+  } else if (operation.type === 'reorder-lane') {
+    const participant = model.nodes.find((candidate) => candidate.id === node?.containerId);
+    changed = participant ? attachLane(model, node, participant, operation.index) : false;
+  } else if (operation.type === 'assign-node') {
+    changed = assignNodeToLane(model, operation.nodeId);
+  } else if (operation.type === 'assign-all') {
+    for (const candidate of model.nodes) if (isFlowNode(candidate)) changed = assignNodeToLane(model, candidate.id) || changed;
+  } else if (operation.type === 'move-container') {
+    changed = moveContainer(model, node, operation.dx || 0, operation.dy || 0);
+  } else if (operation.type === 'resize-container') {
+    changed = resizeNode(model, node, operation.bounds);
+  } else if (operation.type === 'resize-divider') {
+    changed = resizeDivider(model, node, operation.delta || 0);
+  } else if (operation.type === 'update-label-placement') {
+    changed = updateLabelPlacement(model, node, operation.previousPlacement);
+  } else if (operation.type === 'prepare-remove') {
+    if (kindOf(node) === 'participant') {
+      for (const lane of participantLanes(model, node.id)) delete lane.containerId;
+      changed = true;
+    } else if (kindOf(node) === 'lane') {
+      changed = detachLane(model, node, { preservePosition: true }) || changed;
+    }
+    changed = removeNodeFromLanes(model, operation.nodeId) || changed;
+  }
+  return { changed };
+}

package/dist/modules/core/gateway.js

@@ -0,0 +1,72 @@
+const sequenceFlowsFor = (model, predicate) => (model?.edges || [])
+  .filter((edge) => (edge.type || 'sequenceFlow') === 'sequenceFlow')
+  .filter(predicate);
+
+const preset = (id, label, direction, iconId) => Object.freeze({
+  id,
+  label,
+  iconId,
+  nodeType: 'parallelGateway',
+  preset: Object.freeze({
+    name: label,
+    properties: Object.freeze({ gatewayDirection: direction }),
+  }),
+});
+
+export const PARALLEL_GATEWAY_PRESETS = Object.freeze({
+  diverging: preset('parallel-diverging', '并行分支', 'Diverging', 'ui.parallelDiverging'),
+  converging: preset('parallel-converging', '并行汇聚', 'Converging', 'ui.parallelConverging'),
+});
+
+function inferGatewayDirection(incoming, outgoing) {
+  if (incoming.length > 1 && outgoing.length > 1) return 'Mixed';
+  if (incoming.length > 1 && outgoing.length <= 1) return 'Converging';
+  if (outgoing.length > 1 && incoming.length <= 1) return 'Diverging';
+  return 'Unspecified';
+}
+
+function roleIssues(effective, incoming, outgoing) {
+  const issues = [];
+  if (effective === 'Converging') {
+    if (incoming.length < 2) issues.push('并行汇聚至少需要两条入口线路。');
+    if (outgoing.length !== 1) issues.push('并行汇聚通常应只有一条出口线路。');
+  } else if (effective === 'Diverging') {
+    if (incoming.length !== 1) issues.push('并行分支通常应只有一条入口线路。');
+    if (outgoing.length < 2) issues.push('并行分支至少需要两条出口线路。');
+  } else if (effective === 'Mixed') {
+    issues.push('并行网关同时存在多个入口和多个出口，建议拆分为汇聚与分支两个网关。');
+  } else {
+    issues.push('当前线路不足，暂时无法判断并行分支或并行汇聚。');
+  }
+  if (outgoing.some((edge) => String(edge.condition || '').trim())) issues.push('并行网关出口不应设置条件表达式。');
+  if (outgoing.some((edge) => edge.isDefault)) issues.push('并行网关不支持默认出口。');
+  return issues;
+}
+
+export function resolveGatewayRole(model, node) {
+  const incoming = sequenceFlowsFor(model, (edge) => edge.target === node?.id);
+  const outgoing = sequenceFlowsFor(model, (edge) => edge.source === node?.id);
+  const declared = node?.properties?.gatewayDirection || 'Unspecified';
+  const inferred = inferGatewayDirection(incoming, outgoing);
+  const effective = declared === 'Unspecified' ? inferred : declared;
+  const topologyComplete = effective === 'Diverging'
+    ? incoming.length === 1 && outgoing.length >= 2
+    : effective === 'Converging'
+      ? incoming.length >= 2 && outgoing.length === 1
+      : false;
+  const contradictoryTopology = (effective === 'Diverging' && incoming.length > 1)
+    || (effective === 'Converging' && outgoing.length > 1);
+  const invalidOutgoing = outgoing.some((edge) => String(edge.condition || '').trim() || edge.isDefault);
+  const status = ['Unspecified', 'Mixed'].includes(effective)
+    ? 'ambiguous'
+    : contradictoryTopology || invalidOutgoing
+      ? 'conflict'
+      : topologyComplete ? 'valid' : 'incomplete';
+  const issues = roleIssues(effective, incoming, outgoing);
+  return { declared, inferred, effective, incoming, outgoing, topologyComplete, status, issues };
+}
+
+export function validateParallelGateway(model, node) {
+  if (node?.type !== 'parallelGateway') return [];
+  return [...resolveGatewayRole(model, node).issues];
+}

package/dist/modules/core/history.js

@@ -0,0 +1,32 @@
+import { cloneModel } from './model.js';
+
+export class HistoryStack {
+  constructor(limit = 80) {
+    this.limit = limit;
+    this.undoStack = [];
+    this.redoStack = [];
+  }
+
+  capture(model) {
+    this.undoStack.push(cloneModel(model));
+    if (this.undoStack.length > this.limit) this.undoStack.shift();
+    this.redoStack.length = 0;
+  }
+
+  undo(current) {
+    if (!this.undoStack.length) return null;
+    const previous = this.undoStack.pop();
+    this.redoStack.push(cloneModel(current));
+    return previous;
+  }
+
+  redo(current) {
+    if (!this.redoStack.length) return null;
+    const next = this.redoStack.pop();
+    this.undoStack.push(cloneModel(current));
+    return next;
+  }
+
+  get canUndo() { return this.undoStack.length > 0; }
+  get canRedo() { return this.redoStack.length > 0; }
+}