@eventcatalog/core 4.1.4 → 4.2.0

package/eventcatalog/src/stores/sidebar-store/builders/message.ts

@@ -14,6 +14,7 @@ import {
 import { isVisualiserEnabled, isChangelogEnabled } from '@utils/feature';
 import { iconFieldsForResource } from '@utils/icon';
 import { collectionToResourceMap } from '@utils/collections/util';
+import type { MessageTrigger } from '@utils/collections/message-triggers';
 
 type MessageSchemaEntry = CollectionEntry<'schemas'>;
 
@@ -47,16 +48,22 @@ export const buildMessageNode = (
   owners: any[],
   context: ResourceGroupContext,
   hasFieldUsage: boolean = false,
-  flowRefs: string[] = []
+  flowRefs: string[] = [],
+  messageTriggers: { triggers: MessageTrigger[]; triggeredBy: MessageTrigger[] } = { triggers: [], triggeredBy: [] }
 ): NavNode => {
   const producers = message.data.producers || [];
   const consumers = message.data.consumers || [];
   const collection = message.collection;
+  const triggerRefs = [...new Set(messageTriggers.triggers.map(({ message }) => getProducerConsumerPageRef(message)))];
+  const triggeredByRefs = [...new Set(messageTriggers.triggeredBy.map(({ message }) => getProducerConsumerPageRef(message)))];
 
   const renderProducers = producers.length > 0 && shouldRenderSideBarSection(message, 'producers');
   const renderConsumers = consumers.length > 0 && shouldRenderSideBarSection(message, 'consumers');
+  const renderTriggers = triggerRefs.length > 0 && shouldRenderSideBarSection(message, 'triggers');
+  const renderTriggeredBy = triggeredByRefs.length > 0 && shouldRenderSideBarSection(message, 'triggeredBy');
   const renderFlows = flowRefs.length > 0 && shouldRenderSideBarSection(message, 'flows');
   const renderRepository = message.data.repository && shouldRenderSideBarSection(message, 'repository');
+  const hasTriggerPaths = messageTriggers.triggers.length > 0 || messageTriggers.triggeredBy.length > 0;
 
   // Determine badge based on collection type
   const badgeMap: Record<string, string> = {
@@ -124,6 +131,15 @@ export const buildMessageNode = (
             title: 'Map',
             href: buildUrl(`/visualiser/${collection}/${message.data.id}/${message.data.version}`),
           },
+          ...(hasTriggerPaths
+            ? [
+                {
+                  type: 'item' as const,
+                  title: 'Trigger paths',
+                  href: buildUrl(`/triggers/${collection}/${message.data.id}/${message.data.version}`),
+                },
+              ]
+            : []),
         ],
       },
       hasDiagrams && {
@@ -163,6 +179,20 @@ export const buildMessageNode = (
         pages: consumers.map(getProducerConsumerPageRef),
         visible: consumers.length > 0,
       },
+      renderTriggeredBy && {
+        type: 'group',
+        title: 'Triggered by',
+        icon: 'Mail',
+        pages: triggeredByRefs,
+        visible: triggeredByRefs.length > 0,
+      },
+      renderTriggers && {
+        type: 'group',
+        title: 'Triggers',
+        icon: 'Mail',
+        pages: triggerRefs,
+        visible: triggerRefs.length > 0,
+      },
       renderFlows && {
         type: 'group',
         title: 'Appears in flows',

package/eventcatalog/src/stores/sidebar-store/state.ts

@@ -8,6 +8,7 @@ import { getDomains } from '@utils/collections/domains';
 import { getSystems } from '@utils/collections/systems';
 import { getServices } from '@utils/collections/services';
 import { getMessages, pluralizeMessageType } from '@utils/collections/messages';
+import { getTriggeredByOfMessage, getTriggersOfMessage } from '@utils/collections/message-triggers';
 import { getOwner } from '@utils/collections/owners';
 import { getFlows } from '@utils/collections/flows';
 import { getUsers } from '@utils/collections/users';
@@ -451,10 +452,14 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
     {} as Record<string, NavNode | string>
   );
 
-  const rawAgents = await getCollection('agents');
+  const [rawAgents, rawServices, rawDomains] = await Promise.all([
+    getCollection('agents'),
+    getCollection('services'),
+    getCollection('domains'),
+  ]);
+  const messageReceivers = [...rawServices, ...rawAgents, ...rawDomains];
 
   // Compute channels for each service from raw sends[].to / receives[].from pointers
-  const rawServices = await getCollection('services');
   const channelMap = createVersionedMap(channels);
   const serviceChannelsMap = new Map<string, CollectionEntry<'channels'>[]>();
 
@@ -560,7 +565,7 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
     {} as Record<string, NavNode | string>
   );
 
-  // Build a set of message IDs that have field usage declared by any service or agent.
+  // Build a set of message IDs that have field usage declared by any resource that can receive messages.
   // We use raw collections because the hydrated resources replace
   // sends/receives pointers with resolved message entries, which strips the fields property.
   const messagesWithFieldUsage = new Set<string>();
@@ -580,6 +585,14 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
       if (pointer.fields?.length) messagesWithFieldUsage.add(pointer.id);
     }
   }
+  for (const domain of rawDomains) {
+    for (const pointer of domain.data.sends || []) {
+      if (pointer.fields?.length) messagesWithFieldUsage.add(pointer.id);
+    }
+    for (const pointer of domain.data.receives || []) {
+      if (pointer.fields?.length) messagesWithFieldUsage.add(pointer.id);
+    }
+  }
 
   const flowRefsByMessage = buildFlowReferencesByMessage({ flows, events, commands, queries });
 
@@ -588,8 +601,13 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
       const type = pluralizeMessageType(message as any);
       const versionedKey = `${type}:${message.data.id}:${message.data.version}`;
       const hasFieldUsage = messagesWithFieldUsage.has(message.data.id);
+      const triggers = getTriggersOfMessage(messageReceivers, message, messages);
+      const triggeredBy = getTriggeredByOfMessage(messageReceivers, message, messages);
       acc[versionedKey] = withArchitectureDecisionsSection(
-        buildMessageNode(message, owners, context, hasFieldUsage, flowRefsByMessage.get(versionedKey) || []),
+        buildMessageNode(message, owners, context, hasFieldUsage, flowRefsByMessage.get(versionedKey) || [], {
+          triggers,
+          triggeredBy,
+        }),
         message,
         adrs
       );

package/eventcatalog/src/utils/collections/commands.ts

@@ -20,7 +20,7 @@ export const getCommands = async ({ getAllVersions = true, hydrateServices = tru
   const cacheKey = `${getAllVersions ? 'allVersions' : 'currentVersions'}-${hydrateServices ? 'hydrated' : 'minimal'}`;
 
   // Check cache
-  if (memoryCache[cacheKey] && memoryCache[cacheKey].length > 0) {
+  if (memoryCache[cacheKey] && memoryCache[cacheKey].length > 0 && CACHE_ENABLED) {
     // console.timeEnd('✅ New getCommands');
     return memoryCache[cacheKey];
   }

package/eventcatalog/src/utils/collections/message-triggers.ts

@@ -0,0 +1,118 @@
+import type { CollectionEntry } from 'astro:content';
+import type { CollectionMessageTypes } from '@types';
+import { getItemsFromCollectionByIdAndSemverOrLatest, versionMatches } from './util';
+
+type Message = CollectionEntry<CollectionMessageTypes>;
+export type MessageReceiver = CollectionEntry<'services'> | CollectionEntry<'domains'> | CollectionEntry<'agents'>;
+
+interface TriggerPointer {
+  id: string;
+  version?: string;
+  condition?: string;
+}
+
+interface ReceivePointer {
+  id: string;
+  version?: string;
+  triggers?: TriggerPointer[];
+}
+
+export interface MessageTrigger {
+  receiver: MessageReceiver;
+  message: Message;
+  condition?: string;
+}
+
+const messageMatchesPointer = (message: Message, pointer: { id: string; version?: string }) => {
+  if (pointer.id !== message.data.id) return false;
+
+  if (!pointer.version || pointer.version === 'latest') {
+    return !message.data.latestVersion || message.data.version === message.data.latestVersion;
+  }
+
+  return versionMatches(message.data.version, pointer.version);
+};
+
+/**
+ * Returns the messages triggered when a resource receives the given message.
+ *
+ * Receivers must be raw collection entries because hydration replaces receive
+ * pointers with messages and therefore removes trigger metadata.
+ */
+export const getTriggersOfMessage = (
+  receivers: MessageReceiver[],
+  message: Message,
+  allMessages: Message[]
+): MessageTrigger[] => {
+  const triggers: MessageTrigger[] = [];
+
+  for (const receiver of receivers) {
+    const receives = (receiver.data.receives as ReceivePointer[]) ?? [];
+
+    for (const receive of receives) {
+      if (!receive.triggers?.length || !messageMatchesPointer(message, receive)) continue;
+
+      for (const trigger of receive.triggers) {
+        const target = getItemsFromCollectionByIdAndSemverOrLatest(allMessages, trigger.id, trigger.version)[0];
+        if (!target) continue;
+
+        triggers.push({ receiver, message: target, condition: trigger.condition });
+      }
+    }
+  }
+
+  return triggers;
+};
+
+/**
+ * Returns the messages whose handling can trigger the given message.
+ *
+ * Receivers must be raw collection entries because hydration replaces receive
+ * pointers with messages and therefore removes trigger metadata.
+ */
+export const getTriggeredByOfMessage = (
+  receivers: MessageReceiver[],
+  message: Message,
+  allMessages: Message[]
+): MessageTrigger[] => {
+  const triggeredBy: MessageTrigger[] = [];
+
+  for (const receiver of receivers) {
+    const receives = (receiver.data.receives as ReceivePointer[]) ?? [];
+
+    for (const receive of receives) {
+      for (const trigger of receive.triggers ?? []) {
+        if (!messageMatchesPointer(message, trigger)) continue;
+
+        const source = getItemsFromCollectionByIdAndSemverOrLatest(allMessages, receive.id, receive.version)[0];
+        if (!source) continue;
+
+        triggeredBy.push({ receiver, message: source, condition: trigger.condition });
+      }
+    }
+  }
+
+  return triggeredBy;
+};
+
+const getMessageKey = (message: Message) => `${message.collection}:${message.data.id}:${message.data.version}`;
+
+/**
+ * Returns only messages that participate in at least one resolved trigger path.
+ * Both the source and target are included so empty trigger pages are never generated.
+ */
+export const getMessagesWithTriggerPaths = (receivers: MessageReceiver[], allMessages: Message[]): Message[] => {
+  const messageKeysWithPaths = new Set<string>();
+
+  for (const source of allMessages) {
+    const triggers = getTriggersOfMessage(receivers, source, allMessages);
+    if (triggers.length === 0) continue;
+
+    messageKeysWithPaths.add(getMessageKey(source));
+    for (const trigger of triggers) {
+      messageKeysWithPaths.add(getMessageKey(trigger.message));
+    }
+  }
+
+  return allMessages.filter((message) => messageKeysWithPaths.has(getMessageKey(message)));
+};

package/eventcatalog/src/utils/node-graphs/container-node-graph.ts

@@ -143,11 +143,12 @@ export const getNodesAndEdges = async ({
     targetPosition: 'left',
     data: {
       mode,
+      isFocused: true,
       data: {
         ...container.data,
       },
       contextMenu: buildContextMenuForResource({
-        collection: 'entities',
+        collection: 'containers',
         id: container.data.id,
         version: container.data.version,
       }),

package/eventcatalog/src/utils/node-graphs/message-lineage.ts

@@ -0,0 +1,131 @@
+import type { CollectionEntry } from 'astro:content';
+import type { Edge, Node } from '@xyflow/react';
+import type { CollectionMessageTypes } from '@types';
+import type { MessageTrigger } from '@utils/collections/message-triggers';
+import {
+  createEdge,
+  createNode,
+  generateIdForNode,
+  generatedIdForEdge,
+  getColorFromString,
+  getEdgeLabelForMessageAsSource,
+  getEdgeLabelForServiceAsTarget,
+} from './utils/utils';
+import { createTriggerMessageNode, getTriggerReceiverNodeData } from './message-node-graph';
+
+type Message = CollectionEntry<CollectionMessageTypes>;
+
+export type MessageLineageDirection = 'triggeredBy' | 'triggers';
+
+export interface MessageLineageGraph {
+  direction: MessageLineageDirection;
+  condition?: string;
+  source: Message;
+  receiver: MessageTrigger['receiver'];
+  target: Message;
+  relatedMessage: Message;
+  nodes: Node[];
+  edges: Edge[];
+}
+
+export interface MessageLineageScenario {
+  condition?: string;
+}
+
+export interface MessageLineageGroup extends Omit<MessageLineageGraph, 'condition'> {
+  scenarios: MessageLineageScenario[];
+}
+
+const createLineageEdge = (source: any, target: any, label: string, colorMessage: Message): Edge =>
+  createEdge({
+    id: generatedIdForEdge(source, target),
+    source: generateIdForNode(source),
+    target: generateIdForNode(target),
+    label,
+    animated: false,
+    data: {
+      animated: false,
+      customColor: getColorFromString(colorMessage.data.id),
+      rootSourceAndTarget: {
+        source: { id: generateIdForNode(source), collection: source.collection },
+        target: { id: generateIdForNode(target), collection: target.collection },
+      },
+    },
+  });
+
+export const buildMessageLineageGraph = ({
+  currentMessage,
+  relation,
+  direction,
+}: {
+  currentMessage: Message;
+  relation: MessageTrigger;
+  direction: MessageLineageDirection;
+}): MessageLineageGraph => {
+  const source = direction === 'triggeredBy' ? relation.message : currentMessage;
+  const target = direction === 'triggeredBy' ? currentMessage : relation.message;
+  const mode = 'simple';
+
+  const nodes: Node[] = [
+    {
+      ...createTriggerMessageNode(source, mode, source === currentMessage),
+      position: { x: 0, y: 0 },
+    },
+    createNode({
+      id: generateIdForNode(relation.receiver),
+      type: relation.receiver.collection,
+      data: getTriggerReceiverNodeData(relation.receiver, mode),
+      position: { x: 320, y: 0 },
+    }),
+    {
+      ...createTriggerMessageNode(target, mode, target === currentMessage),
+      position: { x: 640, y: 0 },
+    },
+  ];
+
+  return {
+    direction,
+    condition: relation.condition,
+    source,
+    receiver: relation.receiver,
+    target,
+    relatedMessage: relation.message,
+    nodes,
+    edges: [
+      createLineageEdge(source, relation.receiver, getEdgeLabelForMessageAsSource(source), source),
+      createLineageEdge(relation.receiver, target, getEdgeLabelForServiceAsTarget(target), target),
+    ],
+  };
+};
+
+const getResourceKey = (resource: Message | MessageTrigger['receiver']) =>
+  `${resource.collection}:${resource.data.id}:${resource.data.version}`;
+
+export const groupMessageLineageGraphs = (graphs: MessageLineageGraph[]): MessageLineageGroup[] => {
+  const groups = new Map<string, MessageLineageGroup>();
+
+  for (const graph of graphs) {
+    const key = [
+      graph.direction,
+      getResourceKey(graph.source),
+      getResourceKey(graph.receiver),
+      getResourceKey(graph.target),
+    ].join('>');
+    const existingGroup = groups.get(key);
+
+    if (existingGroup) {
+      if (!existingGroup.scenarios.some((scenario) => scenario.condition === graph.condition)) {
+        existingGroup.scenarios.push({ condition: graph.condition });
+      }
+      continue;
+    }
+
+    const { condition, ...lineage } = graph;
+    groups.set(key, {
+      ...lineage,
+      scenarios: [{ condition }],
+    });
+  }
+
+  return [...groups.values()];
+};

package/eventcatalog/src/utils/node-graphs/message-node-graph.ts

@@ -1,6 +1,6 @@
 // import { getColor } from '@utils/colors';
 import { getEvents } from '@utils/collections/events';
-import type { CollectionEntry } from 'astro:content';
+import { getCollection, type CollectionEntry } from 'astro:content';
 import dagre from 'dagre';
 import {
   calculatedNodes,
@@ -42,6 +42,7 @@ import {
 import { getNodesAndEdgesForChannelChain } from './channel-node-graph';
 import { getChannelChain, isChannelsConnected } from '@utils/collections/channels';
 import { getChannels } from '@utils/collections/channels';
+import { getTriggeredByOfMessage, getTriggersOfMessage, type MessageReceiver } from '@utils/collections/message-triggers';
 
 type DagreGraph = any;
 type RoutableResource = CollectionEntry<'agents'> | CollectionEntry<'services'>;
@@ -166,6 +167,52 @@ const getDataProductNodeData = (resource: CollectionEntry<'data-products'>, mode
   contextMenu: buildContextMenuForResource({ collection: 'data-products', id: resource.data.id, version: resource.data.version }),
 });
 
+export const getTriggerReceiverNodeData = (receiver: MessageReceiver, mode: 'simple' | 'full') => {
+  if (receiver.collection !== 'domains') return getRoutableNodeData(receiver, mode);
+
+  return {
+    title: receiver.data.id,
+    mode,
+    domain: {
+      ...receiver,
+      data: {
+        ...receiver.data,
+        // Raw domain entries contain service pointers, while the visualiser's
+        // domain node expects hydrated services in full mode.
+        services: [],
+      },
+    },
+    contextMenu: buildContextMenuForResource({
+      collection: 'domains',
+      id: receiver.data.id,
+      version: receiver.data.version,
+    }),
+  };
+};
+
+export const createTriggerMessageNode = (
+  message: CollectionEntry<CollectionMessageTypes>,
+  mode: 'simple' | 'full',
+  isFocused = false
+) =>
+  createNode({
+    id: generateIdForNode(message),
+    type: message.collection,
+    data: {
+      mode,
+      ...(isFocused ? { isFocused: true } : {}),
+      message: { ...message.data, ...getOperationFields(message.data) },
+      contextMenu: buildContextMenuForMessage({
+        id: message.data.id,
+        version: message.data.version,
+        name: message.data.name,
+        collection: message.collection,
+        schemaPath: (message.data as any).schemaPath,
+      }),
+    },
+    position: { x: 0, y: 0 },
+  });
+
 const getNodesAndEdges = async ({
   id,
   version,
@@ -194,6 +241,19 @@ const getNodesAndEdges = async ({
   // Pre-calculate channel map for O(1) lookups
   const channelMap = createVersionedMap(channels);
 
+  // Trigger metadata lives on raw receive pointers. Hydrated resources replace
+  // those pointers with messages, so load the raw collections for this relation.
+  const [events, commands, queries, services, agents, domains] = await Promise.all([
+    getCollection('events'),
+    getCollection('commands'),
+    getCollection('queries'),
+    getCollection('services'),
+    getCollection('agents'),
+    getCollection('domains'),
+  ]);
+  const allMessages = [...events, ...commands, ...queries] as CollectionEntry<CollectionMessageTypes>[];
+  const messageReceivers = [...services, ...agents, ...domains] as MessageReceiver[];
+
   // We always render the message itself
   nodes.push({
     id: generateIdForNode(message),
@@ -201,6 +261,7 @@ const getNodesAndEdges = async ({
     targetPosition: 'left',
     data: {
       mode,
+      isFocused: true,
       message: {
         ...message.data,
         ...getOperationFields(message.data),
@@ -564,6 +625,63 @@ const getNodesAndEdges = async ({
     }
   });
 
+  const appendNode = (node: Node) => {
+    if (!nodes.some((existingNode: Node) => existingNode.id === node.id)) nodes.push(node);
+  };
+  const appendEdge = (source: any, target: any, label: string, colorMessage: CollectionEntry<CollectionMessageTypes>) => {
+    const id = generatedIdForEdge(source, target);
+    if (edges.some((edge: Edge) => edge.id === id)) return;
+
+    edges.push(
+      createEdge({
+        id,
+        source: generateIdForNode(source),
+        target: generateIdForNode(target),
+        label,
+        data: {
+          customColor: getColorFromString(colorMessage.data.id),
+          rootSourceAndTarget: {
+            source: { id: generateIdForNode(source), collection: source.collection },
+            target: { id: generateIdForNode(target), collection: target.collection },
+          },
+        },
+      })
+    );
+  };
+  const appendReceiver = (receiver: MessageReceiver) => {
+    const receiverId = generateIdForNode(receiver);
+    if (nodes.some((node: Node) => node.id === receiverId)) return;
+
+    appendNode(
+      createNode({
+        id: receiverId,
+        type: receiver.collection,
+        data: getTriggerReceiverNodeData(receiver, mode),
+        position: { x: 0, y: 0 },
+      })
+    );
+
+    if (receiver.collection !== 'domains') {
+      appendAgentToolNodesAndEdges({ agent: receiver, nodes, edges, mode });
+    }
+  };
+
+  // Complete both sides of a trigger chain around the focused message:
+  // triggering message -> receiver -> triggered message.
+  for (const relation of getTriggeredByOfMessage(messageReceivers, message, allMessages)) {
+    appendNode(createTriggerMessageNode(relation.message, mode));
+    appendReceiver(relation.receiver);
+    appendEdge(relation.message, relation.receiver, getEdgeLabelForMessageAsSource(relation.message), relation.message);
+    appendEdge(relation.receiver, message, getEdgeLabelForServiceAsTarget(message), message);
+  }
+
+  for (const relation of getTriggersOfMessage(messageReceivers, message, allMessages)) {
+    appendReceiver(relation.receiver);
+    appendNode(createTriggerMessageNode(relation.message, mode));
+    appendEdge(message, relation.receiver, getEdgeLabelForMessageAsSource(message), message);
+    appendEdge(relation.receiver, relation.message, getEdgeLabelForServiceAsTarget(relation.message), relation.message);
+  }
+
   nodes.forEach((node: any) => {
     flow.setNode(node.id, { width: DEFAULT_NODE_WIDTH, height: DEFAULT_NODE_HEIGHT });
   });

package/eventcatalog/src/utils/node-graphs/services-node-graph.ts

@@ -347,7 +347,10 @@ export const getNodesAndEdges = async ({
     id: generateIdForNode(service),
     sourcePosition: 'right',
     targetPosition: 'left',
-    data: getResourceNodeData(service, mode),
+    data: {
+      ...getResourceNodeData(service, mode),
+      isFocused: service.collection === 'services',
+    },
     type: service.collection,
   });
 
@@ -606,6 +609,17 @@ export const getNodesAndEdges = async ({
       uniqueNodesById.set(node.id, node);
     }
   });
+
+  // Inbound message processing may create the service node before the primary
+  // node is added. Mark the surviving copy after deduplication so the service
+  // currently being viewed always retains its focus treatment.
+  if (service.collection === 'services') {
+    const focusedServiceNode = uniqueNodesById.get(generateIdForNode(service));
+    if (focusedServiceNode) {
+      focusedServiceNode.data = { ...focusedServiceNode.data, isFocused: true };
+    }
+  }
+
   const uniqueNodes = Array.from(uniqueNodesById.values());
 
   uniqueNodes.forEach((node: any) => {

package/eventcatalog/src/utils/node-graphs/utils/utils.ts

@@ -162,7 +162,10 @@ export const buildContextMenuForMessage = ({
   collection: string;
   schemaPath?: string;
 }): ContextMenuItem[] => {
-  const items: ContextMenuItem[] = [{ label: 'Read documentation', href: buildUrl(`/docs/${collection}/${id}/${version}`) }];
+  const items: ContextMenuItem[] = [
+    { label: 'Read documentation', href: buildUrl(`/docs/${collection}/${id}/${version}`) },
+    { label: 'Focus node', href: buildUrl(`/visualiser/${collection}/${id}/${version}`) },
+  ];
 
   if (schemaPath) {
     items.push({
@@ -250,7 +253,10 @@ export const buildContextMenuForService = ({
   specifications?: unknown;
   repository?: { url: string };
 }): ContextMenuItem[] => {
-  const items: ContextMenuItem[] = [{ label: 'Read documentation', href: buildUrl(`/docs/services/${id}/${version}`) }];
+  const items: ContextMenuItem[] = [
+    { label: 'Read documentation', href: buildUrl(`/docs/services/${id}/${version}`) },
+    { label: 'Focus node', href: buildUrl(`/visualiser/services/${id}/${version}`) },
+  ];
 
   const specItems = getSpecMenuItems(specifications, id, version);
   items.push(...specItems);
@@ -283,7 +289,10 @@ export const buildContextMenuForAgent = ({
   version: string;
   repository?: { url: string };
 }): ContextMenuItem[] => {
-  const items: ContextMenuItem[] = [{ label: 'Read documentation', href: buildUrl(`/docs/agents/${id}/${version}`) }];
+  const items: ContextMenuItem[] = [
+    { label: 'Read documentation', href: buildUrl(`/docs/agents/${id}/${version}`) },
+    { label: 'Focus node', href: buildUrl(`/visualiser/agents/${id}/${version}`) },
+  ];
 
   if (repository?.url) {
     items.push({
@@ -315,6 +324,7 @@ export const buildContextMenuForResource = ({
 }): ContextMenuItem[] => {
   return [
     { label: 'Read documentation', href: buildUrl(`/docs/${collection}/${id}/${version}`) },
+    { label: 'Focus node', href: buildUrl(`/visualiser/${collection}/${id}/${version}`) },
     {
       label: 'Read changelog',
       href: buildUrl(`/docs/${collection}/${id}/${version}/changelog`),
@@ -331,7 +341,7 @@ export const buildContextMenuForResource = ({
 export const buildContextMenuForSystem = ({ id, version }: { id: string; version: string }): ContextMenuItem[] => {
   return [
     { label: 'Read documentation', href: buildUrl(`/docs/systems/${id}/${version}`) },
-    { label: 'View map', href: buildUrl(`/visualiser/systems/${id}/${version}`) },
+    { label: 'Focus node', href: buildUrl(`/visualiser/systems/${id}/${version}`) },
     { label: 'View context', href: buildUrl(`/visualiser/systems/${id}/${version}/context`) },
   ];
 };

package/package.json

@@ -7,7 +7,7 @@
   },
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",
-  "version": "4.1.4",
+  "version": "4.2.0",
   "publishConfig": {
     "access": "public"
   },
@@ -116,9 +116,9 @@
     "update-notifier": "^7.3.1",
     "uuid": "^10.0.0",
     "zod": "^4.3.6",
-    "@eventcatalog/linter": "1.1.4",
-    "@eventcatalog/sdk": "2.25.0",
-    "@eventcatalog/visualiser": "^4.0.1"
+    "@eventcatalog/linter": "1.1.5",
+    "@eventcatalog/sdk": "2.26.0",
+    "@eventcatalog/visualiser": "^4.1.0"
   },
   "devDependencies": {
     "@astrojs/check": "^0.9.9",