@eventcatalog/core 4.1.5 → 4.2.0

package/dist/analytics/analytics.cjs

@@ -36,7 +36,7 @@ module.exports = __toCommonJS(analytics_exports);
 var import_os = __toESM(require("os"), 1);
 
 // package.json
-var version = "4.1.5";
+var version = "4.2.0";
 
 // src/constants.ts
 var VERSION = version;

package/dist/analytics/analytics.js

@@ -1,7 +1,7 @@
 import {
   raiseEvent
-} from "../chunk-GIU3S4CI.js";
-import "../chunk-X77TET65.js";
+} from "../chunk-J7T5HUHY.js";
+import "../chunk-4FWALA6J.js";
 export {
   raiseEvent
 };

package/dist/analytics/log-build.cjs

@@ -140,7 +140,7 @@ var verifyRequiredFieldsAreInCatalogConfigFile = async (projectDirectory) => {
 var import_os = __toESM(require("os"), 1);
 
 // package.json
-var version = "4.1.5";
+var version = "4.2.0";
 
 // src/constants.ts
 var VERSION = version;

package/dist/analytics/log-build.js

@@ -1,9 +1,9 @@
 import {
   log_build_default
-} from "../chunk-DIUAURE2.js";
-import "../chunk-GIU3S4CI.js";
+} from "../chunk-47LY7DY2.js";
+import "../chunk-J7T5HUHY.js";
 import "../chunk-K2XIENVT.js";
-import "../chunk-X77TET65.js";
+import "../chunk-4FWALA6J.js";
 import "../chunk-6QENHZZP.js";
 export {
   log_build_default as default

package/dist/{chunk-DIUAURE2.js → chunk-47LY7DY2.js}

@@ -1,6 +1,6 @@
 import {
   raiseEvent
-} from "./chunk-GIU3S4CI.js";
+} from "./chunk-J7T5HUHY.js";
 import {
   countResources,
   serializeCounts

package/dist/{chunk-X77TET65.js → chunk-4FWALA6J.js}

@@ -1,5 +1,5 @@
 // package.json
-var version = "4.1.5";
+var version = "4.2.0";
 
 // src/constants.ts
 var VERSION = version;

package/dist/{chunk-GIU3S4CI.js → chunk-J7T5HUHY.js}

@@ -1,6 +1,6 @@
 import {
   VERSION
-} from "./chunk-X77TET65.js";
+} from "./chunk-4FWALA6J.js";
 
 // src/analytics/analytics.js
 import os from "os";

package/dist/{chunk-G74MXXTG.js → chunk-KPDU47YJ.js}

@@ -1,6 +1,6 @@
 import {
   VERSION
-} from "./chunk-X77TET65.js";
+} from "./chunk-4FWALA6J.js";
 
 // src/utils/cli-logger.ts
 import pc from "picocolors";

package/dist/{chunk-E6IUV4GX.js → chunk-QKPPJU43.js}

@@ -1,6 +1,6 @@
 import {
   logger
-} from "./chunk-G74MXXTG.js";
+} from "./chunk-KPDU47YJ.js";
 import {
   cleanup,
   getEventCatalogConfigFile

package/dist/constants.cjs

@@ -25,7 +25,7 @@ __export(constants_exports, {
 module.exports = __toCommonJS(constants_exports);
 
 // package.json
-var version = "4.1.5";
+var version = "4.2.0";
 
 // src/constants.ts
 var VERSION = version;

package/dist/constants.js

@@ -1,6 +1,6 @@
 import {
   VERSION
-} from "./chunk-X77TET65.js";
+} from "./chunk-4FWALA6J.js";
 export {
   VERSION
 };

package/dist/eventcatalog.cjs

@@ -144,7 +144,7 @@ var verifyRequiredFieldsAreInCatalogConfigFile = async (projectDirectory) => {
 var import_picocolors = __toESM(require("picocolors"), 1);
 
 // package.json
-var version = "4.1.5";
+var version = "4.2.0";
 
 // src/constants.ts
 var VERSION = version;

package/dist/eventcatalog.js

@@ -1,16 +1,16 @@
 import {
   log_build_default
-} from "./chunk-DIUAURE2.js";
+} from "./chunk-47LY7DY2.js";
 import {
   runMigrations
 } from "./chunk-XUAF2H54.js";
 import "./chunk-CA4U2JP7.js";
 import {
   generate
-} from "./chunk-E6IUV4GX.js";
+} from "./chunk-QKPPJU43.js";
 import {
   logger
-} from "./chunk-G74MXXTG.js";
+} from "./chunk-KPDU47YJ.js";
 import {
   resolve_catalog_dependencies_default
 } from "./chunk-LHR4G2UO.js";
@@ -20,7 +20,7 @@ import {
 import {
   watch
 } from "./chunk-CAJUIMDJ.js";
-import "./chunk-GIU3S4CI.js";
+import "./chunk-J7T5HUHY.js";
 import "./chunk-K2XIENVT.js";
 import {
   catalogToAstro
@@ -28,7 +28,7 @@ import {
 import "./chunk-W5JQON7Z.js";
 import {
   VERSION
-} from "./chunk-X77TET65.js";
+} from "./chunk-4FWALA6J.js";
 import {
   linkCoreNodeModules,
   resolveInstalledCoreNodeModules

package/dist/generate.cjs

@@ -108,7 +108,7 @@ var getEventCatalogConfigFile = async (projectDirectory) => {
 var import_picocolors = __toESM(require("picocolors"), 1);
 
 // package.json
-var version = "4.1.5";
+var version = "4.2.0";
 
 // src/constants.ts
 var VERSION = version;

package/dist/generate.js

@@ -1,8 +1,8 @@
 import {
   generate
-} from "./chunk-E6IUV4GX.js";
-import "./chunk-G74MXXTG.js";
-import "./chunk-X77TET65.js";
+} from "./chunk-QKPPJU43.js";
+import "./chunk-KPDU47YJ.js";
+import "./chunk-4FWALA6J.js";
 import "./chunk-6QENHZZP.js";
 export {
   generate

package/dist/utils/cli-logger.cjs

@@ -36,7 +36,7 @@ module.exports = __toCommonJS(cli_logger_exports);
 var import_picocolors = __toESM(require("picocolors"), 1);
 
 // package.json
-var version = "4.1.5";
+var version = "4.2.0";
 
 // src/constants.ts
 var VERSION = version;

package/dist/utils/cli-logger.js

@@ -1,7 +1,7 @@
 import {
   logger
-} from "../chunk-G74MXXTG.js";
-import "../chunk-X77TET65.js";
+} from "../chunk-KPDU47YJ.js";
+import "../chunk-4FWALA6J.js";
 export {
   logger
 };

package/eventcatalog/src/components/Lineage/LineageScenarioSwitcher.tsx

@@ -0,0 +1,65 @@
+import { CheckIcon, ChevronDownIcon } from '@heroicons/react/20/solid';
+import * as DropdownMenu from '@radix-ui/react-dropdown-menu';
+import { useState } from 'react';
+
+interface Props {
+  conditions: string[];
+}
+
+export default function LineageScenarioSwitcher({ conditions }: Props) {
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const selectedCondition = conditions[selectedIndex];
+
+  return (
+    <DropdownMenu.Root>
+      <DropdownMenu.Trigger asChild>
+        <button
+          type="button"
+          className="group inline-flex max-w-full items-center gap-1.5 rounded-md border border-[rgb(var(--ec-dropdown-border)/0.8)] bg-[rgb(var(--ec-dropdown-bg))] px-2 py-1 align-middle text-sm font-semibold text-[rgb(var(--ec-page-text))] shadow-sm transition-colors hover:border-[rgb(var(--ec-accent)/0.5)] hover:bg-[rgb(var(--ec-dropdown-hover))] focus:outline-hidden focus:ring-2 focus:ring-[rgb(var(--ec-accent)/0.3)]"
+          aria-label={`Select scenario. Scenario ${selectedIndex + 1} of ${conditions.length}: ${selectedCondition}`}
+        >
+          <span className="min-w-0 max-w-xl truncate">{selectedCondition}</span>
+          <span className="shrink-0 rounded bg-[rgb(var(--ec-accent-subtle))] px-1.5 py-0.5 text-[10px] font-semibold tabular-nums text-[rgb(var(--ec-accent-text))]">
+            {selectedIndex + 1}/{conditions.length}
+          </span>
+          <ChevronDownIcon className="h-3.5 w-3.5 shrink-0 text-[rgb(var(--ec-page-text-muted))] transition-transform group-data-[state=open]:rotate-180" />
+        </button>
+      </DropdownMenu.Trigger>
+
+      <DropdownMenu.Portal>
+        <DropdownMenu.Content
+          align="start"
+          sideOffset={6}
+          collisionPadding={12}
+          className="z-[1000] max-h-80 w-[min(36rem,calc(100vw-1.5rem))] overflow-y-auto rounded-xl border border-[rgb(var(--ec-dropdown-border)/0.8)] bg-[rgb(var(--ec-dropdown-bg))] p-1.5 shadow-[0_20px_56px_rgb(0_0_0/0.22)]"
+        >
+          <div className="px-2.5 pb-2 pt-1.5">
+            <p className="text-xs font-semibold text-[rgb(var(--ec-dropdown-text))]">Choose a scenario</p>
+            <p className="pt-0.5 text-[11px] font-normal text-[rgb(var(--ec-page-text-muted))]">
+              This message path is shared by {conditions.length} conditions.
+            </p>
+          </div>
+          <DropdownMenu.Separator className="mb-1 h-px bg-[rgb(var(--ec-dropdown-border)/0.7)]" />
+          <DropdownMenu.RadioGroup value={String(selectedIndex)} onValueChange={(value) => setSelectedIndex(Number(value))}>
+            {conditions.map((condition, index) => (
+              <DropdownMenu.RadioItem
+                key={`${condition}-${index}`}
+                value={String(index)}
+                className="relative flex cursor-pointer select-none items-start gap-2.5 rounded-lg px-2.5 py-2 pr-9 text-sm font-normal leading-5 text-[rgb(var(--ec-dropdown-text))] outline-hidden transition-colors data-[highlighted]:bg-[rgb(var(--ec-dropdown-hover))]"
+              >
+                <span className="mt-0.5 flex h-5 min-w-5 items-center justify-center rounded-md bg-[rgb(var(--ec-accent-subtle))] px-1 text-[10px] font-semibold tabular-nums text-[rgb(var(--ec-accent-text))]">
+                  {index + 1}
+                </span>
+                <span>{condition}</span>
+                <DropdownMenu.ItemIndicator className="absolute right-2.5 top-2.5 text-[rgb(var(--ec-accent))]">
+                  <CheckIcon className="h-4 w-4" />
+                </DropdownMenu.ItemIndicator>
+              </DropdownMenu.RadioItem>
+            ))}
+          </DropdownMenu.RadioGroup>
+          <DropdownMenu.Arrow className="fill-[rgb(var(--ec-dropdown-bg))]" />
+        </DropdownMenu.Content>
+      </DropdownMenu.Portal>
+    </DropdownMenu.Root>
+  );
+}

package/eventcatalog/src/content.config.ts

@@ -87,11 +87,18 @@ const sendsPointer = z.object({
     .optional(),
 });
 
+const triggersPointer = z.object({
+  id: z.string(),
+  version: z.string().optional().default('latest'),
+  condition: z.string().optional(),
+});
+
 const receivesPointer = z.object({
   id: z.string(),
   version: z.string().optional().default('latest'),
   fields: z.array(z.string()).optional(),
   group: z.string().optional(),
+  triggers: z.array(triggersPointer).optional(),
   from: z
     .array(
       z.object({
@@ -355,6 +362,8 @@ const operationSchema = z
 const messageDetailsPanelPropertySchema = z.object({
   producers: detailPanelPropertySchema.optional(),
   consumers: detailPanelPropertySchema.optional(),
+  triggers: detailPanelPropertySchema.optional(),
+  triggeredBy: detailPanelPropertySchema.optional(),
   channels: detailPanelPropertySchema.optional(),
   versions: detailPanelPropertySchema.optional(),
   repository: detailPanelPropertySchema.optional(),

package/eventcatalog/src/pages/triggers/[type]/[id]/[version]/_index.data.ts

@@ -0,0 +1,66 @@
+import { getCollection, type CollectionEntry } from 'astro:content';
+import { getMessagesWithTriggerPaths, type MessageReceiver } from '@utils/collections/message-triggers';
+import { isSSR } from '@utils/feature';
+import { HybridPage } from '@utils/page-loaders/hybrid-page';
+import type { CollectionMessageTypes } from '@types';
+
+const MESSAGE_TYPES: CollectionMessageTypes[] = ['events', 'commands', 'queries'];
+
+const loadTriggerPathResources = async () => {
+  const { pageDataLoader } = await import('@utils/page-loaders/page-data-loader');
+  const [messageCollections, services, agents, domains] = await Promise.all([
+    Promise.all(MESSAGE_TYPES.map((type) => pageDataLoader[type]())),
+    getCollection('services'),
+    getCollection('agents'),
+    getCollection('domains'),
+  ]);
+
+  return {
+    allMessages: messageCollections.flat() as CollectionEntry<CollectionMessageTypes>[],
+    receivers: [...services, ...agents, ...domains] as MessageReceiver[],
+  };
+};
+
+export class Page extends HybridPage {
+  static get prerender(): boolean {
+    return !isSSR();
+  }
+
+  static async getStaticPaths(): Promise<Array<{ params: any; props: any }>> {
+    if (isSSR()) return [];
+
+    const { allMessages, receivers } = await loadTriggerPathResources();
+    const messagesWithTriggerPaths = getMessagesWithTriggerPaths(receivers, allMessages);
+
+    return messagesWithTriggerPaths.map((item) => ({
+      params: {
+        type: item.collection,
+        id: item.data.id,
+        version: item.data.version,
+      },
+      props: {
+        type: item.collection,
+        ...item,
+      },
+    }));
+  }
+
+  protected static async fetchData(params: any) {
+    const { type, id, version } = params;
+    if (!type || !id || !version || !MESSAGE_TYPES.includes(type)) return null;
+
+    const { allMessages, receivers } = await loadTriggerPathResources();
+    const item = allMessages.find((entry) => entry.collection === type && entry.data.id === id && entry.data.version === version);
+    if (!item) return null;
+
+    const hasTriggerPaths = getMessagesWithTriggerPaths(receivers, allMessages).includes(item);
+    return hasTriggerPaths ? { type, ...item } : null;
+  }
+
+  protected static createNotFoundResponse(): Response {
+    return new Response(null, {
+      status: 404,
+      statusText: 'Message trigger paths not found',
+    });
+  }
+}

package/eventcatalog/src/pages/triggers/[type]/[id]/[version]/index.astro

@@ -0,0 +1,201 @@
+---
+import { getCollection, type CollectionEntry } from 'astro:content';
+
+import LineageScenarioSwitcher from '@components/Lineage/LineageScenarioSwitcher';
+import AstroNodeGraph from '@components/MDX/NodeGraph/AstroNodeGraph';
+import ResourceRef from '@components/MDX/ResourceRef/ResourceRef.astro';
+import Footer from '@layouts/Footer.astro';
+import VerticalSideBarLayout from '@layouts/VerticalSideBarLayout.astro';
+import { getTriggeredByOfMessage, getTriggersOfMessage, type MessageReceiver } from '@utils/collections/message-triggers';
+import { buildMessageLineageGraph, groupMessageLineageGraphs } from '@utils/node-graphs/message-lineage';
+import type { CollectionMessageTypes } from '@types';
+
+import { Page } from './_index.data';
+
+export const prerender = Page.prerender;
+export const getStaticPaths = Page.getStaticPaths;
+
+const props = await Page.getData(Astro);
+const { data } = props as CollectionEntry<CollectionMessageTypes>;
+const currentMessage = props as CollectionEntry<CollectionMessageTypes>;
+
+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 receivers = [...services, ...agents, ...domains] as MessageReceiver[];
+
+const triggeredByRows = groupMessageLineageGraphs(
+  getTriggeredByOfMessage(receivers, currentMessage, allMessages).map((relation) =>
+    buildMessageLineageGraph({ currentMessage, relation, direction: 'triggeredBy' })
+  )
+);
+const triggerRows = groupMessageLineageGraphs(
+  getTriggersOfMessage(receivers, currentMessage, allMessages).map((relation) =>
+    buildMessageLineageGraph({ currentMessage, relation, direction: 'triggers' })
+  )
+);
+
+const resourceTypeByCollection = {
+  events: 'event',
+  commands: 'command',
+  queries: 'query',
+  services: 'service',
+  domains: 'domain',
+  agents: 'agent',
+} as const;
+const resourceType = (resource: CollectionEntry<CollectionMessageTypes> | MessageReceiver) =>
+  resourceTypeByCollection[resource.collection];
+const conditionText = (condition: string) => condition.replace(/^when\s+/i, '');
+const scenarioConditions = (row: (typeof triggeredByRows)[number]) =>
+  row.scenarios.map(({ condition }) => (condition ? conditionText(condition) : 'No condition specified'));
+---
+
+<VerticalSideBarLayout title={`Trigger paths | ${data.name}`} description={`Message trigger paths for ${data.name}`}>
+  <main class="w-full min-h-full bg-[rgb(var(--ec-page-bg))] py-8">
+    <header class="border-b border-[rgb(var(--ec-page-border))] py-5">
+      <div class="text-sm font-semibold text-[rgb(var(--ec-accent))]">Trigger paths</div>
+      <h1 class="pt-3 text-2xl md:text-4xl font-bold text-[rgb(var(--ec-page-text))]">{data.name}</h1>
+      <p class="pt-3 text-base text-[rgb(var(--ec-page-text-muted))] font-light">
+        Explore the direct messages that trigger this message and the messages it can trigger.
+      </p>
+    </header>
+
+    <div class="space-y-10 py-8">
+      {
+        triggeredByRows.length > 0 && (
+          <section aria-labelledby="triggered-by-heading">
+            <div class="space-y-5">
+              {triggeredByRows.map((row, index) => (
+                <article class="lineage-row overflow-hidden rounded-xl border border-[rgb(var(--ec-page-border))] bg-[rgb(var(--ec-card-bg))] shadow-sm">
+                  <div class="border-b border-[rgb(var(--ec-page-border))] px-5 py-4">
+                    <h3 class="text-sm md:text-base font-medium text-[rgb(var(--ec-page-text))]">
+                      <ResourceRef type={resourceType(row.target)} version={row.target.data.version}>
+                        {row.target.data.id}
+                      </ResourceRef>{' '}
+                      is triggered by{' '}
+                      <ResourceRef type={resourceType(row.source)} version={row.source.data.version}>
+                        {row.source.data.id}
+                      </ResourceRef>
+                      {row.scenarios.length === 1 && row.scenarios[0].condition && (
+                        <>
+                          {' '}
+                          when <span class="font-semibold">{conditionText(row.scenarios[0].condition)}</span>
+                        </>
+                      )}
+                      {row.scenarios.length > 1 && (
+                        <>
+                          {' '}
+                          when <LineageScenarioSwitcher client:visible conditions={scenarioConditions(row)} />
+                        </>
+                      )}{' '}
+                      via{' '}
+                      <ResourceRef type={resourceType(row.receiver)} version={row.receiver.data.version}>
+                        {row.receiver.data.id}
+                      </ResourceRef>
+                    </h3>
+                  </div>
+                  <div
+                    id={`${data.id}-triggered-by-${index}-portal`}
+                    class="lineage-graph h-[250px] w-full bg-[rgb(var(--ec-page-bg))]"
+                  />
+                  <AstroNodeGraph
+                    client:only="react"
+                    id={`${data.id}-triggered-by-${index}`}
+                    portalId={`${data.id}-triggered-by-${index}-portal`}
+                    nodes={row.nodes}
+                    edges={row.edges}
+                    mode="simple"
+                    linkTo="docs"
+                    includeKey={false}
+                    showSearch={false}
+                    zoomOnScroll={false}
+                    disableMessageAnimation={true}
+                  />
+                </article>
+              ))}
+            </div>
+          </section>
+        )
+      }
+
+      {
+        triggerRows.length > 0 && (
+          <section aria-label="Messages triggered by this message">
+            <div class="space-y-5">
+              {triggerRows.map((row, index) => (
+                <article class="lineage-row overflow-hidden rounded-xl border border-[rgb(var(--ec-page-border))] bg-[rgb(var(--ec-card-bg))] shadow-sm">
+                  <div class="border-b border-[rgb(var(--ec-page-border))] px-5 py-4">
+                    <h3 class="text-sm md:text-base font-medium text-[rgb(var(--ec-page-text))]">
+                      <ResourceRef type={resourceType(row.target)} version={row.target.data.version}>
+                        {row.target.data.id}
+                      </ResourceRef>{' '}
+                      is triggered by{' '}
+                      <ResourceRef type={resourceType(row.source)} version={row.source.data.version}>
+                        {row.source.data.id}
+                      </ResourceRef>
+                      {row.scenarios.length === 1 && row.scenarios[0].condition && (
+                        <>
+                          {' '}
+                          when <span class="font-semibold">{conditionText(row.scenarios[0].condition)}</span>
+                        </>
+                      )}
+                      {row.scenarios.length > 1 && (
+                        <>
+                          {' '}
+                          when <LineageScenarioSwitcher client:visible conditions={scenarioConditions(row)} />
+                        </>
+                      )}{' '}
+                      via{' '}
+                      <ResourceRef type={resourceType(row.receiver)} version={row.receiver.data.version}>
+                        {row.receiver.data.id}
+                      </ResourceRef>
+                    </h3>
+                  </div>
+                  <div
+                    id={`${data.id}-triggers-${index}-portal`}
+                    class="lineage-graph h-[250px] w-full bg-[rgb(var(--ec-page-bg))]"
+                  />
+                  <AstroNodeGraph
+                    client:only="react"
+                    id={`${data.id}-triggers-${index}`}
+                    portalId={`${data.id}-triggers-${index}-portal`}
+                    nodes={row.nodes}
+                    edges={row.edges}
+                    mode="simple"
+                    linkTo="docs"
+                    includeKey={false}
+                    showSearch={false}
+                    zoomOnScroll={false}
+                    disableMessageAnimation={true}
+                  />
+                </article>
+              ))}
+            </div>
+          </section>
+        )
+      }
+    </div>
+
+    <Footer />
+  </main>
+</VerticalSideBarLayout>
+
+<style is:global>
+  .lineage-row {
+    content-visibility: auto;
+    contain-intrinsic-size: 330px;
+  }
+
+  .lineage-graph .react-flow__panel.top,
+  .lineage-graph .react-flow__controls,
+  .lineage-graph .react-flow__attribution {
+    display: none;
+  }
+</style>

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.5",
+  "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",