@eventcatalog/core 4.10.15 → 4.11.1

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

@@ -1,15 +1,27 @@
 import fs from 'fs';
 import path from 'path';
+import matter from 'gray-matter';
 import yaml from 'js-yaml';
 import { getResourceBasePath } from '@utils/resource-files';
 
+/**
+ * A usage example for a message: any text file inside the message's `examples/` folder.
+ */
 export interface MessageExample {
+  /** File path relative to the `examples/` folder, for example `basic-order.json`. */
   fileName: string;
+  /** Display title: frontmatter `title`, else the first level-one heading, else the file name. */
   title: string;
+  /** File extension without the leading dot. */
   extension: string;
-  content: string;
+  /** Markdown is rendered as prose; other formats and unsupported MDX are rendered as source. */
+  renderMode: 'markdown' | 'code';
+  /** Optional short description from frontmatter `summary`. */
   summary?: string;
+  /** Optional usage instructions from the legacy examples config. */
   usage?: string;
+  /** File contents. Markdown frontmatter is removed. */
+  content: string;
 }
 
 interface ExampleConfig {
@@ -18,68 +30,148 @@ interface ExampleConfig {
   usage?: string;
 }
 
-function loadConfig(examplesDir: string): Record<string, ExampleConfig> {
-  const yamlPath = path.join(examplesDir, 'examples.config.yaml');
-  const ymlPath = path.join(examplesDir, 'examples.config.yml');
-  const jsonPath = path.join(examplesDir, 'examples.config.json');
-
-  let configPath: string | null = null;
-  if (fs.existsSync(yamlPath)) configPath = yamlPath;
-  else if (fs.existsSync(ymlPath)) configPath = ymlPath;
-  else if (fs.existsSync(jsonPath)) configPath = jsonPath;
+const CONFIG_FILES = new Set(['examples.config.yaml', 'examples.config.yml', 'examples.config.json']);
+const MARKDOWN_EXTENSIONS = new Set(['.md', '.mdx']);
+const CLIENT_RENDERED_MDX_COMPONENTS = new Set(['Column', 'Columns', 'CodeGroup']);
 
+const loadConfig = (examplesDir: string): Record<string, ExampleConfig> => {
+  const configPath = ['examples.config.yaml', 'examples.config.yml', 'examples.config.json']
+    .map((fileName) => path.join(examplesDir, fileName))
+    .find(fs.existsSync);
   if (!configPath) return {};
 
   const raw = fs.readFileSync(configPath, 'utf-8');
-  if (configPath.endsWith('.json')) {
-    return JSON.parse(raw) || {};
-  }
-  return (yaml.load(raw) as Record<string, ExampleConfig>) || {};
-}
+  return configPath.endsWith('.json') ? JSON.parse(raw) || {} : (yaml.load(raw) as Record<string, ExampleConfig>) || {};
+};
 
-const CONFIG_FILES = ['examples.config.yaml', 'examples.config.yml', 'examples.config.json'];
+const humanizeFileName = (fileName: string) =>
+  path
+    .parse(fileName)
+    .name.replace(/[-_]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .replace(/^\w/, (character) => character.toUpperCase());
 
-function collectFiles(dir: string, baseDir: string): Omit<MessageExample, 'summary' | 'usage'>[] {
-  const results: Omit<MessageExample, 'summary' | 'usage'>[] = [];
+const collectExampleFiles = (dir: string, baseDir: string): string[] => {
+  const results: string[] = [];
   const entries = fs.readdirSync(dir, { withFileTypes: true });
 
   for (const entry of entries) {
     const fullPath = path.join(dir, entry.name);
     if (entry.isDirectory()) {
-      results.push(...collectFiles(fullPath, baseDir));
-    } else if (entry.isFile() && !CONFIG_FILES.includes(entry.name)) {
-      results.push({
-        fileName: path.relative(baseDir, fullPath),
-        title: path.parse(entry.name).name,
-        extension: path.parse(entry.name).ext.slice(1),
-        content: fs.readFileSync(fullPath, 'utf-8'),
-      });
+      results.push(...collectExampleFiles(fullPath, baseDir));
+    } else if (entry.isFile() && !CONFIG_FILES.has(entry.name)) {
+      results.push(path.relative(baseDir, fullPath));
     }
   }
 
   return results;
+};
+
+const hasUnsupportedMdxComponent = (content: string) =>
+  [...content.matchAll(/<([A-Z][A-Za-z0-9.]*)\b/g)].some((match) => !CLIENT_RENDERED_MDX_COMPONENTS.has(match[1]));
+
+/**
+ * Splits an example file into its title and Markdown body. The title comes from frontmatter,
+ * else the leading level-one heading, else the file name. The body is left as written.
+ */
+export const parseExampleFile = (fileName: string, raw: string): MessageExample => {
+  const { data, content } = matter(raw);
+  const body = content.replace(/^\s*\n/, '');
+  let title = typeof data.title === 'string' && data.title.trim() ? data.title.trim() : undefined;
+  const extension = path.extname(fileName).slice(1).toLowerCase();
+
+  const headingMatch = body.match(/^#[ \t]+(.+)(?:\r?\n|$)/);
+  if (headingMatch) title = title ?? headingMatch[1].trim();
+
+  return {
+    fileName: fileName.replace(/\\/g, '/'),
+    title: title ?? humanizeFileName(fileName),
+    extension,
+    renderMode: extension === 'mdx' && hasUnsupportedMdxComponent(body) ? 'code' : 'markdown',
+    ...(typeof data.summary === 'string' && data.summary.trim() ? { summary: data.summary.trim() } : {}),
+    content: body.trim(),
+  };
+};
+
+const parseRawExampleFile = (fileName: string, raw: string, config: ExampleConfig = {}): MessageExample => ({
+  fileName: fileName.replace(/\\/g, '/'),
+  title: config.name?.trim() || humanizeFileName(fileName),
+  extension: path.extname(fileName).slice(1).toLowerCase(),
+  renderMode: 'code',
+  ...(config.summary?.trim() ? { summary: config.summary.trim() } : {}),
+  ...(config.usage?.trim() ? { usage: config.usage.trim() } : {}),
+  content: raw,
+});
+
+/** The parts of an `examples` collection entry the schema pages need. */
+export interface ExampleEntryLike {
+  id: string;
+  filePath?: string;
+  body?: string;
+  data: { title?: string; summary?: string };
+}
+
+const normalize = (value: string) => path.resolve(value).replace(/\\/g, '/');
+
+/**
+ * Selects the example entries that belong to a message: the files under the `examples/`
+ * folder beside the message file, sorted by path.
+ */
+export function getExampleEntriesForMessage<T extends ExampleEntryLike>(entries: T[], messageFilePath?: string): T[] {
+  if (!messageFilePath) return [];
+  const examplesDir = `${normalize(path.dirname(messageFilePath))}/examples/`;
+
+  return entries
+    .filter((entry) => entry.filePath && normalize(entry.filePath).startsWith(examplesDir))
+    .sort((a, b) => (a.filePath as string).localeCompare(b.filePath as string));
 }
 
+/**
+ * Display details for a collection entry, mirroring `parseExampleFile`: frontmatter title,
+ * else the first level-one heading, else the file name.
+ */
+export function getExampleEntryDetails(entry: ExampleEntryLike, examplesDir?: string) {
+  const fileName =
+    entry.filePath && examplesDir
+      ? path.relative(examplesDir, entry.filePath).replace(/\\/g, '/')
+      : path.basename(entry.filePath ?? entry.id);
+  const parsed = parseExampleFile(fileName, entry.body ?? '');
+
+  return {
+    fileName,
+    title: entry.data.title?.trim() || parsed.title,
+    summary: entry.data.summary?.trim() || parsed.summary,
+  };
+}
+
+/**
+ * Reads usage examples stored in the `examples/` folder next to a message.
+ */
 export function getExamplesForResource(resource: { filePath?: string }): MessageExample[] {
   const basePath = getResourceBasePath(resource);
   if (!basePath) return [];
 
   const examplesDir = path.join(basePath, 'examples');
   if (!fs.existsSync(examplesDir)) return [];
-
   const config = loadConfig(examplesDir);
-  const files = collectFiles(examplesDir, examplesDir);
-
-  return files
-    .map((file) => {
-      const key = file.fileName.replace(/\\/g, '/');
-      const meta = config[key] || {};
-      return {
-        ...file,
-        title: meta.name || file.title,
-        summary: meta.summary,
-        usage: meta.usage,
-      };
-    })
-    .sort((a, b) => a.fileName.localeCompare(b.fileName));
+
+  return collectExampleFiles(examplesDir, examplesDir)
+    .sort((a, b) => a.localeCompare(b))
+    .map((fileName) => {
+      const raw = fs.readFileSync(path.join(examplesDir, fileName), 'utf-8');
+      const normalizedFileName = fileName.replace(/\\/g, '/');
+      const extension = path.extname(fileName).toLowerCase();
+      if (MARKDOWN_EXTENSIONS.has(extension)) {
+        const example = parseExampleFile(fileName, raw);
+        const metadata = config[normalizedFileName];
+        return {
+          ...example,
+          ...(metadata?.name?.trim() ? { title: metadata.name.trim() } : {}),
+          ...(metadata?.summary?.trim() ? { summary: metadata.summary.trim() } : {}),
+          ...(metadata?.usage?.trim() ? { usage: metadata.usage.trim() } : {}),
+        };
+      }
+      return parseRawExampleFile(fileName, raw, config[normalizedFileName]);
+    });
 }

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

@@ -146,3 +146,46 @@ export const getFlowsNotInAnyResource = async (): Promise<Flow[]> => {
   });
   return flowsNotInAnyResource;
 };
+
+/** A flow that includes a message in one of its steps, reduced to what the schema pages display. */
+export interface FlowReference {
+  id: string;
+  version: string;
+  name?: string;
+  summary?: string;
+}
+
+/**
+ * Finds the flows whose steps send or receive each of the given messages. Step pointers are
+ * matched the same way flow diagrams resolve them (exact version, then semver range, then
+ * latest). Returns a map keyed by `${collection}:${id}:${version}` of the resolved message.
+ */
+export const getFlowsForMessages = async (
+  messages: { collection: string; data: { id: string; version: string } }[]
+): Promise<Map<string, FlowReference[]>> => {
+  const flows = await getCollection('flows');
+  const messageMap = createVersionedMap(messages);
+  const flowsByMessage = new Map<string, FlowReference[]>();
+
+  for (const flow of flows) {
+    if (flow.data.hidden === true) continue;
+    const reference: FlowReference = {
+      id: flow.data.id,
+      version: flow.data.version,
+      ...(flow.data.name ? { name: flow.data.name } : {}),
+      ...(flow.data.summary ? { summary: flow.data.summary } : {}),
+    };
+    const seen = new Set<string>();
+    for (const step of flow.data.steps ?? []) {
+      if (!step.message) continue;
+      const message = findInMap(messageMap, step.message.id, step.message.version);
+      if (!message) continue;
+      const key = `${message.collection}:${message.data.id}:${message.data.version}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      flowsByMessage.set(key, [...(flowsByMessage.get(key) ?? []), reference]);
+    }
+  }
+
+  return flowsByMessage;
+};

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

@@ -49,7 +49,7 @@ export const hydrateProducersAndConsumers = ({
   const toResult = <T extends CollectionEntry<'agents'> | CollectionEntry<'services'> | CollectionEntry<'data-products'>>(
     resource: T
   ) => {
-    if (!hydrate) return { id: resource.data.id, version: resource.data.version };
+    if (!hydrate) return { id: resource.data.id, version: resource.data.version, collection: resource.collection };
     return resource;
   };
 
@@ -193,7 +193,7 @@ export const lookupProducersAndConsumers = ({ message, index, hydrate = true }:
   const toResult = <T extends CollectionEntry<'agents'> | CollectionEntry<'services'> | CollectionEntry<'data-products'>>(
     resource: T
   ) => {
-    if (!hydrate) return { id: resource.data.id, version: resource.data.version };
+    if (!hydrate) return { id: resource.data.id, version: resource.data.version, collection: resource.collection };
     return resource;
   };
 

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

@@ -39,6 +39,21 @@ export const getSchemaURL = (resource: CollectionEntry<PageTypes> | any) => {
   return path.join(publicPath, schemaFilePath ?? '');
 };
 
+/** File extension EventCatalog uses for a schema format, for schemas that have no file name. */
+export const getSchemaExtensionForFormat = (format?: string) => {
+  switch (format?.toLowerCase()) {
+    case 'jsonschema':
+    case 'json':
+      return 'json';
+    case 'avro':
+      return 'avsc';
+    case 'protobuf':
+      return 'proto';
+    default:
+      return format ?? '';
+  }
+};
+
 export const getSchemaFormatFromURL = (url: string) => {
   const pathParts = url.split('.');
   const format = pathParts[pathParts.length - 1];

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

@@ -515,19 +515,21 @@ const getNodesAndEdges = async ({
           (receive) => receive.id === message.data.id && versionMatches(receive.version, message.data.version)
         )?.from ?? [];
 
-      for (const producerChannel of producerChannels) {
-        const producerChannelValue = findInMap(
-          channelMap,
-          producerChannel.id,
-          producerChannel.version
-        ) as CollectionEntry<'channels'>;
-
-        for (const consumerChannel of consumerChannels) {
-          const consumerChannelValue = findInMap(
-            channelMap,
-            consumerChannel.id,
-            consumerChannel.version
-          ) as CollectionEntry<'channels'>;
+      const resolvedProducerChannels = producerChannels
+        .map(
+          (producerChannel) =>
+            findInMap(channelMap, producerChannel.id, producerChannel.version) as CollectionEntry<'channels'> | undefined
+        )
+        .filter((resolved): resolved is CollectionEntry<'channels'> => resolved !== undefined);
+      const resolvedConsumerChannels = consumerChannels
+        .map(
+          (consumerChannel) =>
+            findInMap(channelMap, consumerChannel.id, consumerChannel.version) as CollectionEntry<'channels'> | undefined
+        )
+        .filter((resolved): resolved is CollectionEntry<'channels'> => resolved !== undefined);
+
+      for (const producerChannelValue of resolvedProducerChannels) {
+        for (const consumerChannelValue of resolvedConsumerChannels) {
           const channelChainToRender = getChannelChain(producerChannelValue, consumerChannelValue, channels);
 
           // If there is a chain between them we need to render them al
@@ -573,8 +575,8 @@ const getNodesAndEdges = async ({
         }
       }
 
-      // If producer does not have a any channels defined, we need to connect the message to the consumer directly
-      if (producerChannels.length === 0 && channel) {
+      // If producer does not have any resolved channels, connect via the consumer channel
+      if (resolvedProducerChannels.length === 0 && channel) {
         // Create the channel node
         nodes.push(
           createNode({

package/eventcatalog/src/utils/schema-explorer.ts

@@ -1,15 +1,19 @@
 import { createHash } from 'node:crypto';
-import type { SchemaItem, SchemaDetails, Producer, Consumer } from '@components/SchemaExplorer/types';
+import type { SchemaItem, SchemaDetails, Producer, Consumer, MessageChannel } from '@components/SchemaExplorer/types';
 import { getEvents } from '@utils/collections/events';
 import { getCommands } from '@utils/collections/commands';
 import { getQueries } from '@utils/collections/queries';
 import { getServices, getSpecificationsForService } from '@utils/collections/services';
 import { getDomains, getSpecificationsForDomain } from '@utils/collections/domains';
 import { getDataProducts } from '@utils/collections/data-products';
+import { getAgents } from '@utils/collections/agents';
+import { getFlowsForMessages } from '@utils/collections/flows';
 import { getOwner } from '@utils/collections/owners';
 import { buildUrl } from '@utils/url-builder';
+import { getSchemaExtensionForFormat } from '@utils/collections/schemas';
 import { resourceFileExists, readResourceFile } from '@utils/resource-files';
 import { getExamplesForResource } from '@utils/collections/examples';
+import { attachFlowGraphs, getMessageUsageGraph } from '@utils/schema-usage-graph';
 import { getCollection } from 'astro:content';
 import path from 'path';
 
@@ -37,12 +41,51 @@ async function buildRegistry() {
 
   // Fetch all services
   const services = await getServices({ getAllVersions: true });
+  // Producers and consumers can be services, agents, or data products. Index all three so
+  // compact { id, version } references can be resolved to a resource for display.
+  const [agents, dataProductsForRelationships] = await Promise.all([
+    getAgents({ getAllVersions: true }),
+    getDataProducts({ getAllVersions: true }),
+  ]);
+  type RelationshipResource = (typeof services)[number] | (typeof agents)[number] | (typeof dataProductsForRelationships)[number];
+  const relationshipResources: RelationshipResource[] = [...services, ...agents, ...dataProductsForRelationships];
+  const resourcesByReference = new Map<string, RelationshipResource>();
+  const latestResourceByCollectionAndId = new Map<string, RelationshipResource>();
+  for (const resource of relationshipResources) {
+    const collectionAndId = `${resource.collection}:${resource.data.id}`;
+    resourcesByReference.set(`${collectionAndId}:${resource.data.version}`, resource);
+    if (!latestResourceByCollectionAndId.has(collectionAndId)) latestResourceByCollectionAndId.set(collectionAndId, resource);
+  }
+  const toSchemaRelationships = (references: unknown): Producer[] =>
+    ((references as { id: string; version: string; collection?: Producer['collection'] }[] | undefined) ?? []).map(
+      (reference) => {
+        const collection = reference.collection ?? 'services';
+        const collectionAndId = `${collection}:${reference.id}`;
+        const resource =
+          resourcesByReference.get(`${collectionAndId}:${reference.version}`) ??
+          latestResourceByCollectionAndId.get(collectionAndId);
+        return {
+          id: reference.id,
+          version: reference.version,
+          collection,
+          ...(resource?.data.name ? { name: resource.data.name } : {}),
+          ...(resource?.data.summary ? { summary: resource.data.summary } : {}),
+        };
+      }
+    );
+  const toMessageChannels = (channels: unknown): MessageChannel[] =>
+    ((channels as { data: { id: string; version: string; name?: string } }[] | undefined) ?? []).map((channel) => ({
+      id: channel.data.id,
+      version: channel.data.version,
+      ...(channel.data.name ? { name: channel.data.name } : {}),
+    }));
 
   // Combine all messages
   const allMessages = [...events, ...commands, ...queries];
   const messagesBySchemaReference = new Map(
     allMessages.map((message) => [`${message.collection}:${message.data.id}:${message.data.version}`, message])
   );
+  const flowsByMessage = await getFlowsForMessages(allMessages);
 
   // Read message schemas from the generated schemas collection.
   const messagesWithSchemas = await Promise.all(
@@ -51,11 +94,16 @@ async function buildRegistry() {
         `${schema.data.message.collectionName}:${schema.data.message.id}:${schema.data.message.version}`
       );
       const schemaPath = schema.data.file || schema.data.source.path || '';
-      const schemaExtension = path.extname(schemaPath).slice(1) || schema.data.format;
+      const schemaExtension = path.extname(schemaPath).slice(1) || getSchemaExtensionForFormat(schema.data.format);
       // The collection types describe raw content references. With
-      // hydrateServices: false, the loaders return compact { id, version } pairs.
-      const producers = (message?.data.producers || []) as unknown as Producer[];
-      const consumers = (message?.data.consumers || []) as unknown as Consumer[];
+      // hydrateServices: false, the loaders return compact { id, version } pairs,
+      // so look the service name and summary up for display.
+      const producers = toSchemaRelationships(message?.data.producers);
+      const consumers = toSchemaRelationships(message?.data.consumers);
+      const channels = toMessageChannels(message?.data.messageChannels);
+      const flows =
+        flowsByMessage.get(`${schema.data.message.collectionName}:${schema.data.message.id}:${schema.data.message.version}`) ??
+        [];
 
       return {
         collection: schema.data.message.collectionName,
@@ -70,22 +118,40 @@ async function buildRegistry() {
           // regardless of how many resources reference the message.
           producerName: producers[0]?.id,
         },
-        loadDetails: () => {
+        loadDetails: async () => {
           let examples: SchemaDetails['examples'] = [];
+          let graph: SchemaDetails['graph'];
           if (message) {
             try {
               examples = getExamplesForResource(message);
             } catch (error) {
               console.error(`Error reading examples for ${message.data.id}:`, error);
             }
+            try {
+              graph = await getMessageUsageGraph({
+                collection: message.collection,
+                id: message.data.id,
+                version: message.data.version,
+              });
+            } catch (error) {
+              console.error(`Error building usage graph for ${message.data.id}:`, error);
+            }
           }
           return {
             schemaContent: schema.data.content || '',
             examples,
-            data: { producers, consumers },
+            ...(graph ? { graph } : {}),
+            data: {
+              producers,
+              consumers,
+              flows: await attachFlowGraphs(flows, { id: schema.data.message.id, version: schema.data.message.version }),
+              channels,
+            },
           };
         },
         schemaExtension,
+        ...(schema.data.name ? { schemaName: schema.data.name } : {}),
+        ...(schema.data.ref ? { schemaRef: schema.data.ref, source: schema.data.source } : {}),
       };
     })
   );

package/eventcatalog/src/utils/schema-usage-graph.ts

@@ -0,0 +1,92 @@
+import type { Edge, Node } from '@xyflow/react';
+import config from '@config';
+import {
+  getNodesAndEdgesForCommands,
+  getNodesAndEdgesForEvents,
+  getNodesAndEdgesForQueries,
+} from '@utils/node-graphs/message-node-graph';
+import { getNodesAndEdges as getNodesAndEdgesForFlow } from '@utils/node-graphs/flows-node-graph';
+import { compactVisualiserGraph } from '@utils/node-graphs/compact-visualiser-graph';
+
+export interface MessageUsageGraph {
+  nodes: Node[];
+  edges: Edge[];
+}
+
+const graphBuilders = {
+  events: getNodesAndEdgesForEvents,
+  commands: getNodesAndEdgesForCommands,
+  queries: getNodesAndEdgesForQueries,
+} as const;
+
+/**
+ * The same producer → message → consumer graph the message docs page renders, reduced to the
+ * fields the visualiser needs so it can be sent to the schema pages.
+ */
+export const getMessageUsageGraph = async ({
+  collection,
+  id,
+  version,
+}: {
+  collection: string;
+  id: string;
+  version: string;
+}): Promise<MessageUsageGraph | undefined> => {
+  const build = graphBuilders[collection as keyof typeof graphBuilders];
+  if (!build) return undefined;
+  const { nodes, edges } = await build({
+    id,
+    version,
+    mode: 'simple',
+    channelRenderMode: config.visualiser?.channels?.renderMode === 'single' ? 'single' : 'flat',
+  });
+  return compactVisualiserGraph(nodes as Node[], edges as Edge[]);
+};
+
+/** Identifies the message a diagram is being viewed from, so its node can be highlighted. */
+export interface FocusedMessage {
+  id: string;
+  version: string;
+}
+
+/**
+ * The flow diagram the flow docs page renders, compacted for the schema pages. Steps that
+ * send or receive the focused message get the visualiser's "Viewing" indicator.
+ */
+export const getFlowGraph = async ({
+  id,
+  version,
+  focus,
+}: {
+  id: string;
+  version: string;
+  focus?: FocusedMessage;
+}): Promise<MessageUsageGraph> => {
+  const { nodes, edges } = await getNodesAndEdgesForFlow({ id, version, mode: 'simple' });
+  const focused = (nodes as Node[]).map((node) => {
+    const message = node.data?.message as { id?: string; version?: string } | undefined;
+    return focus && message?.id === focus.id && message?.version === focus.version
+      ? { ...node, data: { ...node.data, isFocused: true } }
+      : node;
+  });
+  return compactVisualiserGraph(focused, edges as Edge[]);
+};
+
+/**
+ * Adds each flow's diagram to the flow usages, highlighting the focused message's steps.
+ * A flow whose diagram fails to build is kept without one.
+ */
+export const attachFlowGraphs = <T extends { id: string; version: string }>(
+  flows: T[],
+  focus?: FocusedMessage
+): Promise<(T & { graph?: MessageUsageGraph })[]> =>
+  Promise.all(
+    flows.map(async (flow) => {
+      try {
+        return { ...flow, graph: await getFlowGraph({ ...flow, focus }) };
+      } catch (error) {
+        console.error(`Error building flow graph for ${flow.id}:`, error);
+        return flow;
+      }
+    })
+  );

package/package.json

@@ -7,7 +7,7 @@
   },
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",
-  "version": "4.10.15",
+  "version": "4.11.1",
   "publishConfig": {
     "access": "public"
   },
@@ -27,6 +27,7 @@
     "!eventcatalog/dist/",
     "!eventcatalog/node_modules/",
     "!eventcatalog/**/__tests__/",
+    "!eventcatalog/**/*.{spec,test}.{js,jsx,cjs,mjs,ts,tsx,cts,mts}",
     "bin/",
     "dist/"
   ],
@@ -119,9 +120,9 @@
     "update-notifier": "^7.3.1",
     "uuid": "^11.1.1",
     "zod": "^4.3.6",
-    "@eventcatalog/linter": "1.1.19",
-    "@eventcatalog/sdk": "2.29.0",
-    "@eventcatalog/visualiser": "^4.1.4"
+    "@eventcatalog/linter": "1.1.20",
+    "@eventcatalog/visualiser": "^4.1.4",
+    "@eventcatalog/sdk": "2.29.1"
   },
   "devDependencies": {
     "@astrojs/check": "^0.9.10",

package/dist/chunk-RDYYZQYU.js

@@ -1,18 +0,0 @@
-// src/astro-output.ts
-var createAstroLineFilter = () => {
-  return (line) => {
-    const isIgnoredGetStaticPathsWarning = line.includes("[router]") && line.includes("getStaticPaths() ignored in dynamic page");
-    return line.includes("[glob-loader]") || isIgnoredGetStaticPathsWarning || /^\s*The collection ".*" does not exist or is empty\. Please check your content config file for errors\.\s*$/.test(line);
-  };
-};
-var createAstroDevLineFilter = () => {
-  const shouldFilterAstroLine = createAstroLineFilter();
-  return (line) => {
-    return shouldFilterAstroLine(line) || line.includes("[router]");
-  };
-};
-
-export {
-  createAstroLineFilter,
-  createAstroDevLineFilter
-};