@manta-eu/react 0.1.9 → 0.1.10

package/src/graph/createNodeRouter.tsx

@@ -0,0 +1,178 @@
+import { ProviderAccountEntityType } from "@manta-eu/ldo/manual-schemas";
+import { attio, brand, coresignal, ga4, google, m, meta, schema, slack } from "@manta-eu/ldo/namespaces";
+import { expandPrefix, type IRI } from "@manta-eu/rdf-lib/namespaces";
+import type { NodeProps } from "@xyflow/react";
+import type { ComponentType } from "react";
+import { AdsDailyReportTemplateView } from "./nodes/AdsDailyReportTemplateView";
+import { AttioCallRecordingView } from "./nodes/AttioCallRecordingView";
+import { AttioCompanyView } from "./nodes/AttioCompanyView";
+import { AttioDealView } from "./nodes/AttioDealView";
+import { AttioMeetingView } from "./nodes/AttioMeetingView";
+import { AttioNoteView } from "./nodes/AttioNoteView";
+import { AttioTaskView } from "./nodes/AttioTaskView";
+import { BrandAssetAnalysisActionView } from "./nodes/BrandAssetAnalysisActionView";
+import { BrandAssetAnalysisView } from "./nodes/BrandAssetAnalysisView";
+import { BrandFontFamilyView } from "./nodes/BrandFontFamilyView";
+import { BrandGuidelinesView } from "./nodes/BrandGuidelinesView";
+import { CoresignalCompanyView } from "./nodes/CoresignalCompanyView";
+import { CoresignalEmployeeView } from "./nodes/CoresignalEmployeeView";
+import { CoresignalExperienceView } from "./nodes/CoresignalExperienceView";
+import { CoresignalJobView } from "./nodes/CoresignalJobView";
+import { CoresignalKeyExecutiveDepartureView } from "./nodes/CoresignalKeyExecutiveDepartureView";
+import { Ga4DailyOverviewView } from "./nodes/Ga4DailyOverviewView";
+import { Ga4FunnelEventCountView } from "./nodes/Ga4FunnelEventCountView";
+import { Ga4TrafficSourceView } from "./nodes/Ga4TrafficSourceView";
+import { GoogleAdGroupAdView } from "./nodes/GoogleAdGroupAdView";
+import { GoogleAdGroupCriterionView } from "./nodes/GoogleAdGroupCriterionView";
+import { GoogleAdGroupView } from "./nodes/GoogleAdGroupView";
+import { GoogleCampaignBudgetView } from "./nodes/GoogleCampaignBudgetView";
+import { GoogleCampaignCriterionView } from "./nodes/GoogleCampaignCriterionView";
+import { GoogleCampaignInsightView } from "./nodes/GoogleCampaignInsightView";
+import { GoogleCampaignView } from "./nodes/GoogleCampaignView";
+import { GoogleCustomerClientView } from "./nodes/GoogleCustomerClientView";
+import { GoogleCustomerView } from "./nodes/GoogleCustomerView";
+import { GoogleSearchTermInsightView } from "./nodes/GoogleSearchTermInsightView";
+import { LinkedinAdAccountView } from "./nodes/LinkedinAdAccountView";
+import { MetaAdAccountActivityView } from "./nodes/MetaAdAccountActivityView";
+import { MetaAdAccountView } from "./nodes/MetaAdAccountView";
+import { MetaAdImageView } from "./nodes/MetaAdImageView";
+import { MetaAdSetView } from "./nodes/MetaAdSetView";
+import { MetaAdView } from "./nodes/MetaAdView";
+import { MetaCampaignView } from "./nodes/MetaCampaignView";
+import { MetaInsightView } from "./nodes/MetaInsightView";
+import { RenderedTemplateView } from "./nodes/RenderedTemplateView";
+import { SchemaActionView } from "./nodes/SchemaActionView";
+import { ShopifyShopView } from "./nodes/ShopifyShopView";
+import { SlackChannelView } from "./nodes/SlackChannelView";
+import { SlackMessageView } from "./nodes/SlackMessageView";
+import { SlackUserView } from "./nodes/SlackUserView";
+import { SlackWorkspaceView } from "./nodes/SlackWorkspaceView";
+import type { EntityView, RDFNode } from "./types";
+
+export type RDFNodeComponent = ComponentType<NodeProps<RDFNode>>;
+
+export type CreateNodeRouterOptions = {
+  wrap: (View: EntityView) => RDFNodeComponent;
+  fallback: RDFNodeComponent;
+};
+
+export type NodeRouter = {
+  getNodeComponent: (entityType?: string, actionShape?: IRI) => RDFNodeComponent;
+  getEntityView: (entityType?: string, actionShape?: IRI) => EntityView | undefined;
+};
+
+const actionShapeNodeEntries: ReadonlyArray<readonly [IRI, EntityView]> = [
+  [expandPrefix(":AdsDailyReportTemplateShape"), AdsDailyReportTemplateView],
+  [expandPrefix("slack:MessageShape"), SlackMessageView],
+  [expandPrefix("brand:AssetAnalysisShape"), BrandAssetAnalysisActionView],
+];
+
+const typedNodeEntries: ReadonlyArray<readonly [IRI, EntityView]> = [
+  [meta.AdImage, MetaAdImageView],
+
+  [meta.Ad, MetaAdView],
+
+  [meta.AdSet, MetaAdSetView],
+
+  [meta.Campaign, MetaCampaignView],
+  [meta.Insight, MetaInsightView],
+  [google.Campaign, GoogleCampaignView],
+  [google.AdGroup, GoogleAdGroupView],
+  [google.AdGroupAd, GoogleAdGroupAdView],
+  [google.AdGroupCriterion, GoogleAdGroupCriterionView],
+  [google.CampaignBudget, GoogleCampaignBudgetView],
+  [google.CampaignCriterion, GoogleCampaignCriterionView],
+  [google.CampaignInsight, GoogleCampaignInsightView],
+  [google.SearchTermInsight, GoogleSearchTermInsightView],
+
+  // Connected-account provider entities (MNT-506)
+  [meta.AdAccount, MetaAdAccountView],
+  [ProviderAccountEntityType.GOOGLE_CUSTOMER, GoogleCustomerView],
+  [google.CustomerClient, GoogleCustomerClientView],
+  [ProviderAccountEntityType.LINKEDIN_AD_ACCOUNT, LinkedinAdAccountView],
+  [ProviderAccountEntityType.SHOPIFY_SHOP, ShopifyShopView],
+  [ProviderAccountEntityType.SLACK_WORKSPACE, SlackWorkspaceView],
+
+  [schema.Action, SchemaActionView],
+
+  [coresignal.Employee, CoresignalEmployeeView],
+  [coresignal.Company, CoresignalCompanyView],
+  [coresignal.Job, CoresignalJobView],
+  [coresignal.Experience, CoresignalExperienceView],
+  [coresignal.KeyExecutiveDeparture, CoresignalKeyExecutiveDepartureView],
+
+  [ga4.TrafficSource, Ga4TrafficSourceView],
+  [ga4.DailyOverview, Ga4DailyOverviewView],
+  [ga4.FunnelEventCount, Ga4FunnelEventCountView],
+
+  [attio.Company, AttioCompanyView],
+  [attio.Deal, AttioDealView],
+  [attio.Note, AttioNoteView],
+  [attio.CallRecording, AttioCallRecordingView],
+  [attio.Meeting, AttioMeetingView],
+  [attio.Task, AttioTaskView],
+
+  [slack.Channel, SlackChannelView],
+  [slack.User, SlackUserView],
+
+  [meta.AdAccountActivity, MetaAdAccountActivityView],
+
+  [m.RenderedTemplate, RenderedTemplateView],
+  [m.AdsDailyReportTemplate, AdsDailyReportTemplateView],
+
+  // Asserted by a Datalog rule, not by a node shape, so codegen emits no class term for it.
+  [expandPrefix("brand:AssetAnalysis"), BrandAssetAnalysisView],
+  [brand.BrandGuidelines, BrandGuidelinesView],
+  [brand.FontFamily, BrandFontFamilyView],
+];
+
+export const typedEntityTypeIris: ReadonlySet<IRI> = new Set(typedNodeEntries.map(([type]) => type as IRI));
+
+// Views that re-present a change's full content (property-table cards), so the activity viewer can
+// drop its raw Changes rows beneath them. Lens-backed summary cards (Meta/Google/Attio) stay out:
+// they show current state, not the change. Registering a new full-property view? Add it here too.
+export const diffSubsumingViewIris: ReadonlySet<IRI> = new Set([
+  expandPrefix("brand:AssetAnalysisShape"),
+  expandPrefix("brand:AssetAnalysis"),
+  brand.BrandGuidelines,
+  brand.FontFamily,
+]);
+
+export const typedActionShapeIris: ReadonlySet<IRI> = new Set(actionShapeNodeEntries.map(([iri]) => iri));
+
+function resolveByType<V>(
+  typeMap: Record<string, V>,
+  actionShapeMap: Record<string, V>,
+  entityType?: string,
+  actionShape?: IRI,
+): V | undefined {
+  if (actionShape) {
+    const byActionShape = actionShapeMap[actionShape] ?? actionShapeMap[expandPrefix(actionShape)];
+    if (byActionShape) return byActionShape;
+  }
+  if (!entityType) return undefined;
+  return typeMap[entityType] ?? typeMap[expandPrefix(entityType)];
+}
+
+export function createNodeRouter(opts: CreateNodeRouterOptions): NodeRouter {
+  const { wrap, fallback } = opts;
+
+  const viewMap: Record<string, EntityView> = Object.fromEntries(typedNodeEntries);
+  const actionShapeViewMap: Record<string, EntityView> = Object.fromEntries(actionShapeNodeEntries);
+
+  const nodeMap: Record<string, RDFNodeComponent> = Object.fromEntries(
+    typedNodeEntries.map(([type, View]) => [type, wrap(View)]),
+  );
+  const actionShapeNodeMap: Record<string, RDFNodeComponent> = Object.fromEntries(
+    actionShapeNodeEntries.map(([iri, View]) => [iri, wrap(View)]),
+  );
+
+  return {
+    getEntityView(entityType, actionShape) {
+      return resolveByType(viewMap, actionShapeViewMap, entityType, actionShape);
+    },
+    getNodeComponent(entityType, actionShape) {
+      return resolveByType(nodeMap, actionShapeNodeMap, entityType, actionShape) ?? fallback;
+    },
+  };
+}

package/src/graph/custom-nodes.tsx

@@ -0,0 +1,81 @@
+import { BaseEdge, EdgeLabelRenderer, getBezierPath, type EdgeProps } from "@xyflow/react";
+import { memo, useMemo } from "react";
+import type { RDFEdge } from "./graph-utils";
+import { DynamicNode } from "./special-nodes/DynamicNode";
+import { TypeSummaryNode } from "./special-nodes/TypeSummaryNode";
+import { useGraphTheme } from "./themes";
+import { cn } from "#style";
+
+const parallelEdgeLabelSpacingPx = 22;
+
+export const LabeledEdge = memo(function LabeledEdge(props: EdgeProps<RDFEdge>) {
+  const { sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, data, style, markerEnd } = props;
+  const theme = useGraphTheme();
+
+  const [edgePath, labelX, labelY] = getBezierPath({
+    sourceX,
+    sourceY,
+    sourcePosition,
+    targetX,
+    targetY,
+    targetPosition,
+  });
+
+  const label = data?.label;
+  const relationshipType = data?.relationshipType;
+  const edgeIndex = data?.edgeIndex ?? 0;
+  const siblingCount = data?.edgeSiblingCount ?? 0;
+
+  const strokeColor = relationshipType ? theme.edge.relationship[relationshipType] : theme.edge.default;
+
+  const edgeStyle = useMemo(() => ({ ...style, stroke: strokeColor, strokeWidth: 1.5 }), [style, strokeColor]);
+
+  const labelStyle = useMemo(() => {
+    let adjustedX = labelX;
+    let adjustedY = labelY;
+
+    if (siblingCount > 1) {
+      const angle = Math.atan2(targetY - sourceY, targetX - sourceX);
+      const perpX = -Math.sin(angle);
+      const perpY = Math.cos(angle);
+      const offset = (edgeIndex - (siblingCount - 1) / 2) * parallelEdgeLabelSpacingPx;
+      adjustedX = labelX + perpX * offset;
+      adjustedY = labelY + perpY * offset;
+    }
+
+    return {
+      transform: `translate(-50%, -50%) translate(${adjustedX}px, ${adjustedY}px)`,
+    };
+  }, [labelX, labelY, edgeIndex, siblingCount, sourceX, sourceY, targetX, targetY]);
+
+  return (
+    <>
+      <BaseEdge path={edgePath} markerEnd={markerEnd} style={edgeStyle} />
+      {label && (
+        <EdgeLabelRenderer>
+          <div
+            className={cn(
+              "absolute px-1.5 py-[1px] rounded-[4px] typography-tiny",
+              "bg-background/95",
+              "text-muted-foreground",
+              "border border-default-border/80",
+              "pointer-events-none shadow-[0_1px_2px_rgba(0,0,0,0.05)]",
+            )}
+            style={labelStyle}
+          >
+            {label}
+          </div>
+        </EdgeLabelRenderer>
+      )}
+    </>
+  );
+});
+
+export const nodeTypes = {
+  rdfNode: DynamicNode,
+  typeSummaryNode: TypeSummaryNode,
+} as const;
+
+export const edgeTypes = {
+  labeledEdge: LabeledEdge,
+} as const;

package/src/graph/detail-views.tsx

@@ -0,0 +1,66 @@
+import { google, meta } from "@manta-eu/ldo/namespaces";
+import { expandPrefix } from "@manta-eu/rdf-lib/namespaces";
+import type { ComponentType } from "react";
+import { GoogleAdGroupAdDisplay } from "../ad-preview/GoogleAdGroupAdDisplay";
+import { GoogleAdGroupAdPluralDisplay } from "../ad-preview/GoogleAdGroupAdPluralDisplay";
+import { MetaAdDisplay } from "../ad-preview/MetaAdDisplay";
+import { MetaAdPluralDisplay } from "../ad-preview/MetaAdPluralDisplay";
+import { EntityStripDisplay } from "./EntityStripDisplay";
+
+export type DetailView = ComponentType<{ iri: string }>;
+export type PluralView = ComponentType<{ iris: string[] }>;
+
+const detailViewEntries: ReadonlyArray<readonly [string, DetailView]> = [
+  [meta.Ad, MetaAdDisplay],
+  [google.AdGroupAd, GoogleAdGroupAdDisplay],
+];
+
+const pluralViewEntries: ReadonlyArray<readonly [string, PluralView]> = [
+  [meta.Ad, MetaAdPluralDisplay],
+  [google.AdGroupAd, GoogleAdGroupAdPluralDisplay],
+];
+
+export const detailViewTypeIris = detailViewEntries.map(([typeIri]) => typeIri);
+
+const detailViewMap = new Map<string, DetailView>(detailViewEntries);
+const pluralViewMap = new Map<string, PluralView>(pluralViewEntries);
+
+function findForTypes<View>(views: Map<string, View>, rdfTypes: readonly string[]): View | undefined {
+  for (const rdfType of rdfTypes) {
+    const view = views.get(rdfType) ?? views.get(expandPrefix(rdfType));
+
+    if (view) return view;
+  }
+
+  return undefined;
+}
+
+export function findDetailViewForTypes(rdfTypes: readonly string[]): DetailView | undefined {
+  return findForTypes(detailViewMap, rdfTypes);
+}
+
+const stripViews = new WeakMap<DetailView, PluralView>();
+
+function stripViewFor(View: DetailView): PluralView {
+  const cached = stripViews.get(View);
+
+  if (cached) return cached;
+
+  const strip: PluralView = function EntityStrip(props) {
+    return <EntityStripDisplay iris={props.iris} View={View} />;
+  };
+
+  stripViews.set(View, strip);
+
+  return strip;
+}
+
+export function findPluralViewForTypes(rdfTypes: readonly string[]): PluralView | undefined {
+  const override = findForTypes(pluralViewMap, rdfTypes);
+
+  if (override) return override;
+
+  const View = findForTypes(detailViewMap, rdfTypes);
+
+  return View ? stripViewFor(View) : undefined;
+}

package/src/graph/ego-graph.ts

@@ -0,0 +1,316 @@
+import { type JsonLdGraphDocument, type JsonLdNode, getNodeTypes, isJsonLdNode } from "@manta-eu/rdf-lib/jsonld";
+import Graph from "graphology";
+import { humanizePredicateName, shortenUri } from "./graph-utils";
+import { readVocabValue } from "./nodes/typed-node-helpers";
+import type { SampleInstance } from "./types";
+
+export type TypeEnrichment = {
+  sampleInstances: SampleInstance[];
+  allInstances: SampleInstance[];
+  isInEgoChain: boolean;
+};
+
+const labelPredicateSuffixes = ["label", "name", "title", "displayname"];
+
+function isLabelPredicate(predicate: string): boolean {
+  const lower = predicate.toLowerCase();
+  return labelPredicateSuffixes.some((suffix) => lower.endsWith(suffix));
+}
+
+export function extractNodeDisplayData(jsonLdNode: JsonLdNode): {
+  label: string;
+  properties: Array<{ key: string; value: string }>;
+} {
+  const id = jsonLdNode["@id"] ?? "";
+  const types = getNodeTypes(jsonLdNode);
+  const type = types[0];
+
+  let label: string | undefined;
+  const properties: Array<{ key: string; value: string }> = [];
+
+  for (const [predicate, value] of Object.entries(jsonLdNode)) {
+    if (predicate.startsWith("@")) continue;
+    if (predicate === "rdf:type" || predicate === "http://www.w3.org/1999/02/22-rdf-syntax-ns#type") continue;
+
+    if (isLabelPredicate(predicate)) {
+      const labelValue = extractStringValue(value);
+      if (labelValue && !label) {
+        label = labelValue;
+      }
+      continue;
+    }
+
+    if (isJsonLdNode(value) && value["@id"]) continue;
+    if (Array.isArray(value) && value.length > 0 && isJsonLdNode(value[0]) && value[0]["@id"]) continue;
+
+    const stringValue = extractLiteralValue(value);
+    if (stringValue !== undefined) {
+      properties.push({ key: humanizePredicateName(predicate), value: stringValue });
+    }
+  }
+
+  if (!label) {
+    const rankValue = readVocabValue(jsonLdNode, "rank") ?? jsonLdNode["rank"];
+    if (rankValue !== undefined && rankValue !== null) {
+      label = `#${rankValue}`;
+    }
+  }
+
+  if (!label) {
+    for (const [key, value] of Object.entries(jsonLdNode)) {
+      if (key.startsWith("@")) continue;
+      if (isLabelPredicate(key) && typeof value === "string") {
+        label = value;
+        break;
+      }
+    }
+  }
+
+  if (!label) {
+    const nameVal = jsonLdNode["schema:name"] ?? jsonLdNode[":originalFilename"] ?? jsonLdNode[":name"];
+    if (typeof nameVal === "string") label = nameVal;
+  }
+
+  if (!label) {
+    let localName: string;
+    try {
+      localName = decodeURIComponent(shortenUri(id)).replace(/^[:#]/, "");
+    } catch {
+      localName = shortenUri(id).replace(/^[:#]/, "");
+    }
+
+    if (type) {
+      const typeName = shortenUri(type)
+        .replace(/^[:#]/, "")
+        .replace(/([a-z])([A-Z])/g, "$1 $2");
+      const idSuffix = localName.replace(new RegExp(`^${typeName.replace(/\s/g, "")}[_-]?`), "");
+      if (idSuffix && idSuffix !== localName && idSuffix.length > 6) {
+        label = `${typeName} ${idSuffix.slice(0, 8)}...`;
+      } else {
+        label = typeName;
+      }
+    } else {
+      label = localName.length > 40 ? `${localName.slice(0, 35)}...` : localName;
+    }
+  }
+
+  return { label, properties };
+}
+
+function extractStringValue(value: unknown): string | undefined {
+  if (typeof value === "string") return value;
+  if (isJsonLdNode(value) && typeof value["@value"] === "string") return value["@value"];
+  if (Array.isArray(value) && value.length > 0) {
+    const first = value[0];
+    if (typeof first === "string") return first;
+    if (isJsonLdNode(first) && typeof first["@value"] === "string") return first["@value"];
+  }
+  return undefined;
+}
+
+function extractLiteralValue(value: unknown): string | undefined {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (isJsonLdNode(value) && value["@value"] !== undefined) {
+    const v = value["@value"];
+    if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") return String(v);
+  }
+  if (Array.isArray(value)) {
+    const parts = value
+      .filter((v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean")
+      .map((v) => String(v));
+    if (parts.length > 0) return parts.join(" | ");
+  }
+  return undefined;
+}
+
+function normalizeNodeId(rawId: unknown): string | null {
+  if (rawId === null || rawId === undefined) return null;
+  if (typeof rawId === "string") {
+    const normalized = rawId.trim();
+    return normalized.length > 0 ? normalized : null;
+  }
+  if (typeof rawId === "number" || typeof rawId === "boolean" || typeof rawId === "bigint") {
+    return String(rawId);
+  }
+  return null;
+}
+
+export function buildGraphologyGraph(jsonLd: JsonLdGraphDocument): Graph {
+  const graph = new Graph({ type: "directed" });
+
+  for (const node of jsonLd["@graph"]) {
+    const id = normalizeNodeId(node["@id"]);
+    if (!id) continue;
+    const types = getNodeTypes(node);
+    const nextType = types[0] ?? "unknown";
+
+    if (!graph.hasNode(id)) {
+      try {
+        graph.addNode(id, { type: nextType });
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("already exist in the graph")) {
+          continue;
+        }
+        throw error;
+      }
+      continue;
+    }
+
+    const currentType = graph.getNodeAttribute(id, "type") as string | undefined;
+    if ((currentType === undefined || currentType === "unknown") && nextType !== "unknown") {
+      graph.setNodeAttribute(id, "type", nextType);
+    }
+  }
+
+  for (const node of jsonLd["@graph"]) {
+    const id = normalizeNodeId(node["@id"]);
+    if (!id) continue;
+
+    for (const [predicate, value] of Object.entries(node)) {
+      if (predicate.startsWith("@")) continue;
+
+      const targets: string[] = [];
+      const singleTargetId = isJsonLdNode(value) ? normalizeNodeId(value["@id"]) : null;
+      if (singleTargetId && graph.hasNode(singleTargetId)) {
+        targets.push(singleTargetId);
+      } else if (Array.isArray(value)) {
+        for (const item of value) {
+          const itemTargetId = isJsonLdNode(item) ? normalizeNodeId(item["@id"]) : null;
+          if (itemTargetId && graph.hasNode(itemTargetId)) {
+            targets.push(itemTargetId);
+          }
+        }
+      }
+
+      for (const targetId of targets) {
+        if (!graph.hasEdge(id, targetId)) {
+          graph.addEdge(id, targetId, { predicate });
+        }
+      }
+    }
+  }
+
+  return graph;
+}
+
+function greedyTypePath(graph: Graph, start: string): string[] {
+  const chain: string[] = [];
+  const visited = new Set<string>();
+  const seenTypes = new Set<string>();
+
+  let current: string | undefined = start;
+
+  while (current !== undefined) {
+    visited.add(current);
+    chain.push(current);
+    seenTypes.add(graph.getNodeAttribute(current, "type") as string);
+
+    let bestNext: string | undefined;
+    let bestIsNewType = false;
+
+    graph.forEachOutNeighbor(current, (neighbor) => {
+      if (visited.has(neighbor)) return;
+      const neighborType = graph.getNodeAttribute(neighbor, "type") as string;
+      const isNewType = !seenTypes.has(neighborType);
+      if (isNewType && !bestIsNewType) {
+        bestIsNewType = true;
+        bestNext = neighbor;
+      } else if (!bestIsNewType && bestNext === undefined) {
+        bestNext = neighbor;
+      }
+    });
+
+    current = bestNext;
+  }
+
+  return chain;
+}
+
+export function findRepresentativeChain(graph: Graph): Set<string> {
+  if (graph.order === 0) return new Set();
+
+  const sources: string[] = [];
+  graph.forEachNode((nodeId) => {
+    if (graph.inDegree(nodeId) === 0) {
+      sources.push(nodeId);
+    }
+  });
+
+  const candidates = sources.length > 0 ? sources : graph.nodes().slice(0, 1);
+
+  let bestChain: string[] = [];
+  let bestTypeCount = 0;
+
+  for (const start of candidates.slice(0, 50)) {
+    const chain = greedyTypePath(graph, start);
+    const typeCount = new Set(chain.map((n) => graph.getNodeAttribute(n, "type") as string)).size;
+    if (typeCount > bestTypeCount) {
+      bestTypeCount = typeCount;
+      bestChain = chain;
+    }
+  }
+
+  return new Set(bestChain);
+}
+
+export function computeSummaryEnrichment(jsonLd: JsonLdGraphDocument): Map<string, TypeEnrichment> {
+  const result = new Map<string, TypeEnrichment>();
+  const graph = buildGraphologyGraph(jsonLd);
+
+  const chainNodeIds = findRepresentativeChain(graph);
+
+  const nodesByType = new Map<string, Map<string, JsonLdNode>>();
+  for (const node of jsonLd["@graph"]) {
+    const id = normalizeNodeId(node["@id"]);
+    if (!id) continue;
+    const types = getNodeTypes(node);
+    const primaryType = types[0] ?? "unknown";
+    const group = nodesByType.get(primaryType) ?? new Map<string, JsonLdNode>();
+    const existing = group.get(id);
+    if (!existing) {
+      group.set(id, node);
+    } else {
+      group.set(id, { ...existing, ...node, "@id": id });
+    }
+    nodesByType.set(primaryType, group);
+  }
+
+  const chainTypes = new Set<string>();
+  for (const nodeId of chainNodeIds) {
+    if (graph.hasNode(nodeId)) {
+      chainTypes.add(graph.getNodeAttribute(nodeId, "type") as string);
+    }
+  }
+
+  for (const [type, nodeMap] of nodesByType) {
+    const nodes = Array.from(nodeMap.values());
+    const chainNodes = nodes.filter((n) => n["@id"] && chainNodeIds.has(n["@id"]));
+    const nonChainNodes = nodes.filter((n) => !n["@id"] || !chainNodeIds.has(n["@id"]));
+
+    const prioritized = [...chainNodes, ...nonChainNodes];
+    const allInstances: SampleInstance[] = prioritized.map((node) => {
+      const { label, properties } = extractNodeDisplayData(node);
+      return {
+        id: node["@id"] ?? "",
+        label,
+        type,
+        properties,
+      };
+    });
+
+    const sampleInstances: SampleInstance[] = allInstances.slice(0, 3).map((inst) => ({
+      ...inst,
+      properties: inst.properties.slice(0, 2),
+    }));
+
+    result.set(type, {
+      sampleInstances,
+      allInstances,
+      isInEgoChain: chainTypes.has(type),
+    });
+  }
+
+  return result;
+}