@eventcatalog/core 5.7.2 → 5.7.5

package/eventcatalog/src/utils/node-graphs/domain-levels-node-graph.ts

@@ -4,6 +4,7 @@ import { getNodesAndEdges as getServiceNodesAndEdges } from './services-node-gra
 import { getNodesAndEdgesForDomainSystems as getDomainContextNodesAndEdges } from './system-context-node-graph';
 import { getServices } from '@utils/collections/services';
 import { getAgents } from '@utils/collections/agents';
+import { versionMatches } from '@utils/collections/util';
 import { createTriggerMessageNode } from './message-node-graph';
 import {
   createEdge,
@@ -28,6 +29,8 @@ type Tree = { domain: any; groupId: string; parentId?: string }[];
 type Owners = Map<string, { domain: any; system?: any }>;
 
 const MESSAGE_TYPES = new Set(['events', 'commands', 'queries']);
+// Commands and queries belong to what receives them (it handles them), as events do to what sends them
+const RECEIVER_OWNED_TYPES = new Set(['commands', 'queries']);
 const SERVICE_TYPES = new Set(['services', 'agents']);
 
 const systemGroupId = (system: any) => `system-group-${system.data.id}-${system.data.version}`;
@@ -43,6 +46,45 @@ const isInside = (nodes: Map<string, any>, nodeId: string, groupId: string) => {
   return false;
 };
 
+/**
+ * Whether a node (or the services another domain stands for, `receivedBy`) says
+ * it receives a message: its id, and its version (or range, or latest). Undefined
+ * when it doesn't say what it receives
+ */
+const saysItReceives = (node: any, message: any, receivedBy?: any[]): boolean | undefined => {
+  const receives = (node?.data?.service ?? node?.data?.agent)?.receives ?? receivedBy;
+  if (!receives) return undefined;
+  const { id, version } = message?.data?.message ?? {};
+  return receives.some((pointer: any) => {
+    const received = pointer.data ?? pointer;
+    return received.id === id && versionMatches(version ?? '', received.version ?? 'latest');
+  });
+};
+
+/**
+ * What a message reaches, through any channels (not the channels themselves).
+ * Past a channel, only what doesn't say it receives something else: a channel
+ * can carry other messages, to consumers of their own
+ */
+const receiversThroughChannels = (messageId: string, nodes: Map<string, any>, receiversOf: Map<string, string[]>) => {
+  const message = nodes.get(messageId);
+  const receivers: string[] = [];
+  const seen = new Set([messageId]);
+  for (let current = [messageId]; current.length > 0; ) {
+    const throughChannel = current[0] !== messageId;
+    const next = current.flatMap((nodeId) => receiversOf.get(nodeId) ?? []).filter((nodeId) => !seen.has(nodeId));
+    next.forEach((nodeId) => seen.add(nodeId));
+    receivers.push(
+      ...next.filter(
+        (nodeId) =>
+          nodes.get(nodeId)?.type !== 'channels' && (!throughChannel || saysItReceives(nodes.get(nodeId), message) !== false)
+      )
+    );
+    current = next.filter((nodeId) => nodes.get(nodeId)?.type === 'channels');
+  }
+  return receivers;
+};
+
 /** A system shown as a single node (not expanded into what's inside it) */
 const createSystemNode = (system: any, parentId?: string) => ({
   id: generateIdForNode(system),
@@ -97,14 +139,16 @@ const createDomainCard = (domain: any, { parentId, subdomain = false }: { parent
  * systems is shown as a card. Messages a (sub)domain sends or receives itself
  * (`domainMessages`: by message, the boxes drawn with it) fold into it, as a
  * system's do into the system, when only one does (more than one, they connect
- * through the message instead, rather than to each other).
+ * through the message instead, rather than to each other). `receivedBy` has
+ * what the services other domains stand for receive, by the node shown for them.
  */
 export const collapseSystems = (
   graph: Graph,
   systems: any[],
   contextNodes: Map<string, any>,
   subdomains: Map<string, any>,
-  domainMessages: Map<string, Set<string>> = new Map()
+  domainMessages: Map<string, Set<string>> = new Map(),
+  receivedBy: Map<string, any[]> = new Map()
 ): Graph => {
   const nodesById = new Map(graph.nodes.map((node) => [node.id, node]));
   const systemsByGroupId = new Map<string, any>(systems.map((system: any) => [systemGroupId(system), system]));
@@ -123,11 +167,32 @@ export const collapseSystems = (
     cards.set(groupId, createDomainCard(subdomain, { parentId: nodesById.get(groupId)?.parentId, subdomain: true }));
   });
 
+  const sendersOf = new Map<string, string[]>();
+  graph.edges.forEach((edge) => sendersOf.set(edge.target, [...(sendersOf.get(edge.target) ?? []), edge.source]));
+  const carries = (nodeId: string) => nodesById.has(nodeId) && isCarrier(nodesById.get(nodeId));
+  const isMessage = (nodeId: string) => MESSAGE_TYPES.has(nodesById.get(nodeId)?.type);
+  const isChannel = (nodeId: string) => nodesById.get(nodeId)?.type === 'channels';
+
+  // A message is shown as what sends it, not where it's drawn, which can be with
+  // one of its consumers. Sent from more than one, it's left as it is (connecting
+  // each sender to what receives it, rather than one to the rest). None when nothing sends it
+  const senderHomes = new Map<string, string | undefined>();
+  const senderHome = (nodeId: string): string | undefined => {
+    if (!senderHomes.has(nodeId)) {
+      const senders = new Set((sendersOf.get(nodeId) ?? []).filter((sender) => !carries(sender)).map(representative));
+      const [sender] = [...senders];
+      senderHomes.set(nodeId, senders.size > 1 ? nodeId : sender);
+    }
+    return senderHomes.get(nodeId);
+  };
+
   // The node something is shown as: its system, the card of the subdomain it's
   // in, the (sub)domain it's in, or itself
   const representative = (nodeId: string): string => {
     const boxes = domainMessages.get(nodeId);
     if (boxes?.size === 1) return representative([...boxes][0]);
+    const home = isMessage(nodeId) ? senderHome(nodeId) : undefined;
+    if (home) return home;
     for (let node = nodesById.get(nodeId); node; node = node.parentId ? nodesById.get(node.parentId) : undefined) {
       const system: any = systemsByGroupId.get(node.id);
       if (system) return generateIdForNode(system);
@@ -149,6 +214,29 @@ export const collapseSystems = (
   );
   const shownNodes = new Map([...otherNodes, ...systemNodes, ...cards.values()].map((node) => [node.id, node]));
 
+  // The messages sent through a channel (and the channels before it)
+  const messagesThrough = (channelId: string, seen = new Set<string>()): string[] => {
+    if (seen.has(channelId)) return [];
+    seen.add(channelId);
+    return (sendersOf.get(channelId) ?? []).flatMap((sender) =>
+      isMessage(sender) ? [sender] : isChannel(sender) ? messagesThrough(sender, seen) : []
+    );
+  };
+  const receives = (nodeId: string, messageId: string) =>
+    saysItReceives(nodesById.get(nodeId), nodesById.get(messageId), receivedBy.get(nodeId)) ?? false;
+
+  // Where an edge is from and the messages it carries. A channel is one node for
+  // all its messages, so an edge out of one is from each message sent through it
+  // that its target receives (all of them when that isn't known), as those
+  // messages are shown. Edges into a channel are shown by the edges out of it
+  const edgeSources = (edge: any): { from: string; messages: string[] }[] => {
+    if (isChannel(edge.target) && carries(edge.source)) return [];
+    const through = isChannel(edge.source) ? messagesThrough(edge.source) : [];
+    if (through.length === 0) return [{ from: edge.source, messages: [edge.source, edge.target].filter(isMessage) }];
+    const sent = through.filter((messageId) => receives(edge.target, messageId));
+    return (sent.length > 0 ? sent : through).map((messageId) => ({ from: messageId, messages: [messageId] }));
+  };
+
   // Edges between systems / actors / domains: context relationships as they
   // are, edges to nodes kept as their first label, the rest labelled with the
   // messages they carry
@@ -156,28 +244,30 @@ export const collapseSystems = (
     string,
     { source: string; target: string; messages: Map<string, string>; relationship?: any; label?: string; crossDomain?: boolean }
   >();
-  graph.edges.forEach((edge) => {
-    const source = representative(edge.source);
-    const target = representative(edge.target);
-    if (
-      source === target ||
-      !shownNodes.has(source) ||
-      !shownNodes.has(target) ||
-      // One shown node inside another (e.g. a system in its domain)
-      isInside(shownNodes, source, target) ||
-      isInside(shownNodes, target, source)
-    )
-      return;
-    const key = `${source}->${target}`;
-    const connection = connections.get(key) ?? { source, target, messages: new Map<string, string>() };
-    if (edge.id.startsWith(CONTEXT_EDGE_PREFIX)) connection.relationship = edge;
-    if (edge.data?.crossDomain) connection.crossDomain = true;
-    [edge.source, edge.target].forEach((nodeId) => {
-      const node = nodesById.get(nodeId);
-      if (MESSAGE_TYPES.has(node?.type)) connection.messages.set(node.data?.message?.name ?? nodeId, node.type);
-    });
-    connections.set(key, connection);
-  });
+  graph.edges.forEach((edge) =>
+    edgeSources(edge).forEach(({ from, messages }) => {
+      const source = representative(from);
+      const target = representative(edge.target);
+      if (
+        source === target ||
+        !shownNodes.has(source) ||
+        !shownNodes.has(target) ||
+        // One shown node inside another (e.g. a system in its domain)
+        isInside(shownNodes, source, target) ||
+        isInside(shownNodes, target, source)
+      )
+        return;
+      const key = `${source}->${target}`;
+      const connection = connections.get(key) ?? { source, target, messages: new Map<string, string>() };
+      if (edge.id.startsWith(CONTEXT_EDGE_PREFIX)) connection.relationship = edge;
+      if (edge.data?.crossDomain) connection.crossDomain = true;
+      messages.forEach((messageId) => {
+        const node = nodesById.get(messageId);
+        connection.messages.set(node.data?.message?.name ?? messageId, node.type);
+      });
+      connections.set(key, connection);
+    })
+  );
 
   // A relationship already connects the pair (either way), so skip messages
   const related = new Set(
@@ -222,7 +312,7 @@ export const buildDomainTree = (domain: any, findDomain: (id: string, version?:
   return tree;
 };
 
-/** Which domain (and system) each service belongs to, and the domain each subdomain is in */
+/** Which domain (and system) each service or agent belongs to, and the domain each subdomain is in */
 export const collectOwners = (domains: any[]) => {
   const owners: Owners = new Map();
   const parentDomainOf = new Map<string, any>();
@@ -234,9 +324,9 @@ export const collectOwners = (domains: any[]) => {
       if (!parentDomainOf.has(subdomain.data.id)) parentDomainOf.set(subdomain.data.id, d);
     });
   });
-  // Services outside systems, unless a system already claims them
+  // Services outside systems, unless a system already claims them, and agents (systems don't have them)
   domains.forEach((d: any) =>
-    (d.data.services || []).forEach((service: any) => {
+    [...(d.data.services || []), ...(d.data.agents || [])].forEach((service: any) => {
       const serviceId = generateIdForNode(service);
       if (!owners.has(serviceId)) owners.set(serviceId, { domain: d });
     })
@@ -298,8 +388,10 @@ export const buildDomainGraph = ({
     ])
   );
   const edges: any[] = [];
-  // Nodes replaced by another (services in other domains become the domain)
+  // Nodes replaced by another (services in other domains become the domain),
+  // and what each of them receives
   const replacedBy = new Map<string, string>();
+  const replacedReceives = new Map<string, any[]>();
 
   // Other domains are shown as a single card, with counts of what's in them. A
   // subdomain of another domain is shown inside a box for that domain (and
@@ -364,6 +456,7 @@ export const buildDomainGraph = ({
       const owner = SERVICE_TYPES.has(node.type) ? owners.get(node.id) : undefined;
       if (owner && !groupOfDomain.has(owner.domain.data.id)) {
         replacedBy.set(node.id, addOtherDomain(owner.domain));
+        replacedReceives.set(node.id, (node.data?.service ?? node.data?.agent)?.receives ?? []);
         return;
       }
       if (owner && owner.system) {
@@ -384,7 +477,12 @@ export const buildDomainGraph = ({
       }
       // Messages, channels, data stores: kept in the first graph they appear in
       if (nodes.has(node.id)) return;
-      nodes.set(node.id, node.parentId || !inside || SERVICE_TYPES.has(node.type) ? node : { ...node, parentId: inside });
+      // A service or agent in no domain isn't in the system whose graph it came from
+      if (SERVICE_TYPES.has(node.type)) {
+        nodes.set(node.id, { ...node, parentId: undefined, extent: undefined });
+        return;
+      }
+      nodes.set(node.id, node.parentId || !inside ? node : { ...node, parentId: inside });
     });
 
   systems.forEach(({ system, groupId: domainGroup }, index) => {
@@ -438,13 +536,19 @@ export const buildDomainGraph = ({
     if (boxId) replacedBy.set(replaced, boxId);
   });
 
-  const graphEdges = connectEdges(edges, new Map([...cardBoxes, ...replacedBy]), nodes);
-  placeMessagesWithPublishers(nodes, graphEdges, new Set(domainMessages.keys()));
+  const graphEdges = dropReceivesThroughChannels(connectEdges(edges, new Map([...cardBoxes, ...replacedBy]), nodes), nodes);
+  placeMessagesWithOwners(nodes, graphEdges, new Set(domainMessages.keys()));
+  // What the services each other domain stands for receive, by the node shown for the domain
+  const receivedBy = new Map<string, any[]>();
+  replacedBy.forEach((nodeId, replaced) =>
+    receivedBy.set(nodeId, [...(receivedBy.get(nodeId) ?? []), ...(replacedReceives.get(replaced) ?? [])])
+  );
   return {
     nodes,
     edges: graphEdges,
     otherDomainIds: new Set([...replacedBy.values(), ...[...otherDomainIds].map((id) => cardBoxes.get(id) ?? id)]),
     domainMessages,
+    receivedBy,
   };
 };
 
@@ -480,14 +584,6 @@ const addDomainMessages = ({
   const treeDomainIds = new Set(tree.map((entry) => entry.domain.data.id));
   const otherDomainIds = new Set<string>();
   const domainMessages = new Map<string, Set<string>>();
-  // The domain each agent is in (owners only has services): the tree's versions first
-  const agentOwners = new Map<string, any>();
-  [...tree.map((entry) => entry.domain), ...domains].forEach((domain) =>
-    (domain.data.agents || []).forEach((agent: any) => {
-      const agentId = generateIdForNode(agent);
-      if (!agentOwners.has(agentId)) agentOwners.set(agentId, domain);
-    })
-  );
   // Whether a domain or service sends (or receives) the message (their messages are already looked up)
   const lists = (resource: any, key: 'sends' | 'receives', messageId: string) =>
     (resource.data[key] || []).some((message: any) => message.data && generateIdForNode(message) === messageId);
@@ -513,19 +609,19 @@ const addDomainMessages = ({
     return false;
   };
   // Whether a service in a (sub)domain's box says it sends (or receives) the message: e.g. one it sends in a
-  // message group, which its graph shows as the group rather than the message. Services only: agents in a
-  // domain aren't drawn on its diagram
+  // message group, which its graph shows as the group rather than the message. Services only: a domain's
+  // agents are only drawn when another graph brings them in
   const groupOfTreeDomain = new Map(tree.map((entry) => [entry.domain.data.id, entry.groupId]));
   const declaredIn = (groupId: string, key: 'sends' | 'receives', messageId: string) =>
     catalogServices.some((service) => {
-      if (!lists(service, key, messageId)) return false;
+      if (service.collection === 'agents' || !lists(service, key, messageId)) return false;
       const ownerGroup = groupOfTreeDomain.get(owners.get(generateIdForNode(service))?.domain.data.id);
       return !!ownerGroup && (ownerGroup === groupId || isInside(nodes, ownerGroup, groupId));
     });
   // The node standing for a service (or agent) on the other side, or none when it's in the domain
   const otherSide = (service: any) => {
     const serviceId = generateIdForNode(service);
-    const ownerDomain = owners.get(serviceId)?.domain ?? agentOwners.get(serviceId);
+    const ownerDomain = owners.get(serviceId)?.domain;
     if (ownerDomain) return treeDomainIds.has(ownerDomain.data.id) ? undefined : addOther(ownerDomain);
     if (!nodes.has(serviceId)) {
       nodes.set(serviceId, {
@@ -609,27 +705,77 @@ const addDomainMessages = ({
 /**
  * Messages are placed in the first graph they appear in, which can be a
  * system consuming them. Moves each message into the system (or domain) of the
- * services publishing it, when they're all in the same one. Messages a domain
+ * services it belongs to, when they're all in the same one: an event's
+ * publishers, a command's or query's receivers (through any channels). Each
+ * channel goes with the messages sent through it. Messages a domain
  * sends or receives itself (`kept`) stay outside its box, where its edge to them
  * is drawn.
  */
-export const placeMessagesWithPublishers = (nodes: Map<string, any>, edges: any[], kept: Set<string> = new Set()) => {
-  const publisherGroups = new Map<string, Set<string | undefined>>();
+export const placeMessagesWithOwners = (nodes: Map<string, any>, edges: any[], kept: Set<string> = new Set()) => {
+  const ownerGroups = new Map<string, Set<string | undefined>>();
+  const addOwner = (messageId: string, owner: any) =>
+    ownerGroups.set(messageId, (ownerGroups.get(messageId) ?? new Set()).add(owner.parentId));
+  const receiversOf = new Map<string, string[]>();
+  edges.forEach((edge) => receiversOf.set(edge.source, [...(receiversOf.get(edge.source) ?? []), edge.target]));
   edges.forEach((edge) => {
     const publisher = nodes.get(edge.source);
-    if (!MESSAGE_TYPES.has(nodes.get(edge.target)?.type) || !SERVICE_TYPES.has(publisher?.type)) return;
-    const groups = publisherGroups.get(edge.target) || new Set();
-    groups.add(publisher.parentId);
-    publisherGroups.set(edge.target, groups);
+    const type = nodes.get(edge.target)?.type;
+    if (!MESSAGE_TYPES.has(type) || RECEIVER_OWNED_TYPES.has(type) || !SERVICE_TYPES.has(publisher?.type)) return;
+    addOwner(edge.target, publisher);
+  });
+  nodes.forEach((message, messageId) => {
+    if (!RECEIVER_OWNED_TYPES.has(message.type)) return;
+    receiversThroughChannels(messageId, nodes, receiversOf)
+      .filter((nodeId) => SERVICE_TYPES.has(nodes.get(nodeId)?.type))
+      .forEach((nodeId) => addOwner(messageId, nodes.get(nodeId)));
   });
-  publisherGroups.forEach((groups, messageId) => {
+  ownerGroups.forEach((groups, messageId) => {
     if (kept.has(messageId)) return;
     const [parentId] = [...groups];
     const message = nodes.get(messageId);
-    if (groups.size === 1 && parentId && message.parentId !== parentId) {
+    // Owners are drawn nodes, so no parent means outside every box (e.g. a service or agent in no domain)
+    if (groups.size === 1 && message.parentId !== parentId) {
       nodes.set(messageId, { ...message, parentId, extent: undefined });
     }
   });
+
+  // Channels go with what sends through them (messages, or channels before them), when that's all in one place
+  const sendersOf = new Map<string, string[]>();
+  edges.forEach((edge) => sendersOf.set(edge.target, [...(sendersOf.get(edge.target) ?? []), edge.source]));
+  for (let moved = true; moved; ) {
+    moved = false;
+    nodes.forEach((channel, channelId) => {
+      if (channel.type !== 'channels' || kept.has(channelId)) return;
+      const senders = (sendersOf.get(channelId) ?? []).filter((sender) => nodes.has(sender));
+      const groups = new Set(senders.map((sender) => nodes.get(sender).parentId));
+      const [parentId] = [...groups];
+      if (groups.size === 1 && channel.parentId !== parentId) {
+        nodes.set(channelId, { ...channel, parentId, extent: undefined });
+        moved = true;
+      }
+    });
+  }
+};
+
+/**
+ * Drops the edges drawn for domains receiving a message themselves (`domain-receives-`)
+ * when the message already reaches them through its channels, e.g. another
+ * domain listing a command in its `receives` whose service receives it from a
+ * queue: the domain is drawn receiving it from the queue, not from the command too.
+ */
+const dropReceivesThroughChannels = (edges: any[], nodes: Map<string, any>) => {
+  const isChannel = (nodeId: string) => nodes.get(nodeId)?.type === 'channels';
+  const reachesThroughChannels = (messageId: string, targetId: string) => {
+    const seen = new Set<string>();
+    for (let current = [messageId]; current.length > 0; ) {
+      const next = edges.filter((edge) => current.includes(edge.source) && isChannel(edge.target) && !seen.has(edge.target));
+      if (next.some((edge) => edges.some((out) => out.source === edge.target && out.target === targetId))) return true;
+      next.forEach((edge) => seen.add(edge.target));
+      current = next.map((edge) => edge.target);
+    }
+    return false;
+  };
+  return edges.filter((edge) => !edge.id.startsWith('domain-receives-') || !reachesThroughChannels(edge.source, edge.target));
 };
 
 /**
@@ -683,15 +829,19 @@ export const addContext = (contexts: Graph[], systems: { system: any }[], nodes:
 };
 
 /**
- * Marks cross-domain communication. Messages and channels only other domains
- * send to (e.g. a message this domain consumes, and the topic it comes
+ * Marks cross-domain communication. Events and channels only other domains
+ * send to (e.g. an event this domain consumes, and the topic it comes
  * through) are another domain's: they sit outside this domain, between the
  * domain sending them and their consumers, rather than in the system that
- * consumes them. They, and this domain's messages and channels that reach
+ * consumes them. Commands and queries belong to what receives them, so those
+ * (and the channels only they're sent through) only other domains receive are
+ * another domain's, and those this domain receives are its own, whoever sends
+ * them. Messages and channels other domains send, and this domain's that reach
  * other domains, are on a cross-domain path (`data.crossDomain`), as are the
  * edges to and from them and other domains.
  */
 export const markCrossDomain = (graph: Graph, otherDomainIds: Set<string>): Graph => {
+  const nodesById = new Map(graph.nodes.map((node) => [node.id, node]));
   const sendersOf = new Map<string, string[]>();
   const receiversOf = new Map<string, string[]>();
   graph.edges.forEach((edge) => {
@@ -718,16 +868,45 @@ export const markCrossDomain = (graph: Graph, otherDomainIds: Set<string>): Grap
     return reached;
   };
   // Sent only by other domains (or their messages and channels)
-  const external = spread(new Set(otherDomainIds), (nodeId, reached) => {
+  const sentByOthers = spread(new Set(otherDomainIds), (nodeId, reached) => {
     const senders = sendersOf.get(nodeId) || [];
     return senders.length > 0 && senders.every((sender) => reached.has(sender));
   });
+  // Received only by other domains (or their messages and channels)
+  const receivedByOthers = spread(new Set(otherDomainIds), (nodeId, reached) => {
+    const receivers = receiversOf.get(nodeId) || [];
+    return receivers.length > 0 && receivers.every((receiver) => reached.has(receiver));
+  });
   // Reaching other domains (directly, or through messages and channels that do)
-  const outgoing = spread(new Set(external), (nodeId, reached) =>
+  const outgoing = spread(new Set(sentByOthers), (nodeId, reached) =>
     (receiversOf.get(nodeId) || []).some((receiver) => reached.has(receiver))
   );
 
-  const isExternalCarrier = (node: any) => external.has(node.id) && !otherDomainIds.has(node.id);
+  // A command or query, or a channel only they're sent through (by channel, worked out once: routes can split and
+  // join again)
+  const receiverOwnedChannels = new Map<string, boolean>();
+  const isReceiverOwned = (nodeId: string): boolean => {
+    const node = nodesById.get(nodeId);
+    if (MESSAGE_TYPES.has(node?.type)) return RECEIVER_OWNED_TYPES.has(node.type);
+    if (node?.type !== 'channels') return false;
+    if (!receiverOwnedChannels.has(nodeId)) {
+      // Not the receiver's while it's being worked out, so a loop of channels ends
+      receiverOwnedChannels.set(nodeId, false);
+      const carried = (sendersOf.get(nodeId) || []).filter((sender) => nodesById.has(sender) && isCarrier(nodesById.get(sender)));
+      receiverOwnedChannels.set(nodeId, carried.length > 0 && carried.every(isReceiverOwned));
+    }
+    return receiverOwnedChannels.get(nodeId)!;
+  };
+  // A command or query only other domains receive (not counting consumers of other messages on its channels)
+  const receivedOnlyByOthers = (messageId: string) => {
+    const receivers = receiversThroughChannels(messageId, nodesById, receiversOf);
+    return receivers.length > 0 && receivers.every((receiver) => otherDomainIds.has(receiver));
+  };
+  const isExternalCarrier = (node: any) => {
+    if (!isCarrier(node) || otherDomainIds.has(node.id)) return false;
+    if (RECEIVER_OWNED_TYPES.has(node.type)) return receivedOnlyByOthers(node.id);
+    return (isReceiverOwned(node.id) ? receivedByOthers : sentByOthers).has(node.id);
+  };
   const onCrossDomainPath = (nodeId: string) => outgoing.has(nodeId);
   return {
     nodes: graph.nodes.map((node) => {
@@ -775,11 +954,8 @@ export const getNodesAndEdges = (props: NodesAndEdgesProps): Promise<DomainLevel
  * or its latest when no domain has it: who sends or receives a domain's own
  * messages is matched against these.
  */
-const inVersionsUsed = (resources: any[], domains: any[], owners: Owners) => {
-  const used = new Set([
-    ...owners.keys(),
-    ...domains.flatMap((domain) => (domain.data.agents || []).map((agent: any) => generateIdForNode(agent))),
-  ]);
+const inVersionsUsed = (resources: any[], owners: Owners) => {
+  const used = new Set(owners.keys());
   const key = (resource: any) => `${resource.collection}:${resource.data.id}`;
   const usedKeys = new Set(resources.filter((resource) => used.has(generateIdForNode(resource))).map(key));
   return resources.filter((resource) =>
@@ -809,11 +985,11 @@ const buildLevels = async ({ id, version, mode = 'full', channelRenderMode }: No
   const tree = buildDomainTree(domain, findDomain);
   // The tree's domains last, so the versions shown own their services
   const { owners, parentDomainOf } = collectOwners([...domains, ...tree.map((entry) => entry.domain)]);
-  // A service the domain (or a subdomain) lists itself is shown as its own,
-  // even when a system in another domain has it too
+  // A service (or agent) the domain or a subdomain lists itself is shown as its
+  // own, even when a system in another domain has it too
   const treeDomainIds = new Set(tree.map((entry) => entry.domain.data.id));
   tree.forEach(({ domain: d }) =>
-    (d.data.services || []).forEach((service: any) => {
+    [...(d.data.services || []), ...(d.data.agents || [])].forEach((service: any) => {
       const serviceId = generateIdForNode(service);
       if (!treeDomainIds.has(owners.get(serviceId)?.domain.data.id)) owners.set(serviceId, { domain: d });
     })
@@ -860,7 +1036,7 @@ const buildLevels = async ({ id, version, mode = 'full', channelRenderMode }: No
     ),
   ]);
 
-  const { nodes, edges, otherDomainIds, domainMessages } = buildDomainGraph({
+  const { nodes, edges, otherDomainIds, domainMessages, receivedBy } = buildDomainGraph({
     tree,
     owners,
     parentDomainOf,
@@ -870,7 +1046,7 @@ const buildLevels = async ({ id, version, mode = 'full', channelRenderMode }: No
     serviceGraphs,
     mode,
     domains,
-    catalogServices: inVersionsUsed([...services, ...agents], [...domains, ...tree.map((entry) => entry.domain)], owners),
+    catalogServices: inVersionsUsed([...services, ...agents], owners),
   });
   const context = addContext(contexts, systems, nodes);
   const graph = { nodes: [...nodes.values(), ...context.nodes], edges: [...edges, ...context.edges] };
@@ -881,14 +1057,15 @@ const buildLevels = async ({ id, version, mode = 'full', channelRenderMode }: No
   // by services not in one) are hidden too, with the nodes either side connected
   // directly. A domain without systems or subdomains has no level 1.
   if (systems.length === 0 && tree.length === 1) return layoutLevels(detailedGraph);
-  // Built from the graph before messages only other domains send were moved
-  // out of the systems consuming them, so they collapse into those systems
+  // Built from the graph before other domains' messages were moved out of the
+  // systems they were drawn in, so they collapse into those systems
   const collapsed = collapseSystems(
     { ...graph, edges: detailedGraph.edges },
     systems.map(({ system }) => system),
     context.contextNodesById,
     new Map(tree.filter((entry) => entry.parentId).map((entry) => [entry.groupId, entry.domain])),
-    domainMessages
+    domainMessages,
+    receivedBy
   );
   const overview = hideMessageNodes(collapsed.nodes, collapsed.edges);