@atlaskit/editor-plugin-show-diff 14.3.2 → 14.4.0

package/dist/es2019/pm-plugins/decorations/createInlineChangedDecoration.js

@@ -5,6 +5,7 @@ import { isExtendedEnabled } from '../isExtendedEnabled';
 import { buildAtomicInlineChangedCSSVariables, buildDeletedInlineContentStyleExtended, buildDeletedInlineStyle, buildDeletedInlineStyleStandard, buildInsertStyle, buildInsertStyleActive, buildInsertStyleExtended, buildInsertStyleExtendedActive, buildInsertStyleExtendedNoUnderline, buildInsertStyleExtendedNoUnderlineActive } from './colorSchemes/factory';
 import { colorSchemeRegistry, getLegacyColorScheme } from './colorSchemes/schemes';
 import { createInlineIndicatorAnchorWidgets } from './createAnchorDecorationWidgets';
+import { createContributorTagWidget } from './createContributorTagWidget';
 import { getAtomicInlineNodeClassNameLegacy, resolveInlineChangedStyleLegacy } from './createInlineChangedDecoration.styles.legacy';
 import { buildDiffDecorationSpec } from './decorationKeys';
 const displayNoneStyle = convertToInlineCss({
@@ -92,28 +93,38 @@ export const getAtomicInlineChangedAttrs = (inlineNodeName, colorScheme) => reso
  */
 
 export const createInlineChangedDecoration = ({
+  attributionKey,
   change,
   colorScheme,
   isActive = false,
   isInserted = true,
   isAtomicInlineNode = false,
   shouldHideDeleted = false,
+  showContributorTags = false,
   showIndicators = false,
   doc,
   diffType,
   hideAddedDiffsUnderline = false,
   inlineNodeName,
   hasDeletedWidget = false,
-  isDeletedWidgetBelow = false
+  isDeletedWidgetBelow = false,
+  tagMountContext
 }) => {
-  const diffId = crypto.randomUUID();
+  // Derived from the range so it survives a recalculation: stepping to the next/previous change
+  // rebuilds decorations without touching the doc, and a fresh id would change the React key and the
+  // tag host's key, remounting every tag mid-step. Random ids are kept when tags are off.
+  const diffId = showContributorTags ? `inline-${change.fromB}-${change.toB}` : crypto.randomUUID();
   if (shouldHideDeleted) {
     return [Decoration.inline(change.fromB, change.toB, {
       style: displayNoneStyle
     }, buildDiffDecorationSpec({
+      // No attribution: this decoration paints nothing and emits no tag host, so a tag
+      // resolved from it would have nowhere to render.
+      colorScheme,
       decorationType: 'inline',
       diffId,
-      isActive
+      isActive,
+      isInserted
     }))];
   }
   const colors = getColorScheme(colorScheme);
@@ -132,11 +143,18 @@ export const createInlineChangedDecoration = ({
     ...(atomicInlineAttrs && {
       class: atomicInlineAttrs.className
     }),
-    'data-testid': 'show-diff-changed-decoration'
+    'data-testid': 'show-diff-changed-decoration',
+    // Lets the contributor tag find its highlight on hover.
+    ...(showContributorTags && {
+      'data-diff-id': diffId
+    })
   }, buildDiffDecorationSpec({
+    attributionKey,
+    colorScheme,
     decorationType: 'inline',
     diffId,
-    isActive
+    isActive,
+    isInserted
   }))];
   if (showIndicators && doc && isExtendedEnabled(diffType)) {
     // For paragraphs, fromB/toB land on the outer block
@@ -173,5 +191,20 @@ export const createInlineChangedDecoration = ({
       diffId
     }));
   }
+
+  // Built from the raw change range, not the anchors above: a tag lines up with the changed text,
+  // while the bar's anchors are held on a block boundary when a deleted widget renders beside them.
+  if (showContributorTags && doc && isExtendedEnabled(diffType)) {
+    const tagWidget = createContributorTagWidget({
+      doc,
+      from: change.fromB,
+      to: change.toB,
+      diffId,
+      mountContext: tagMountContext
+    });
+    if (tagWidget) {
+      decorations.push(tagWidget);
+    }
+  }
   return decorations;
 };

package/dist/es2019/pm-plugins/decorations/createNodeChangedDecorationWidget.js

@@ -3,6 +3,7 @@ import { fg } from '@atlaskit/platform-feature-flags/fg';
 import { isExtendedEnabled } from '../isExtendedEnabled';
 import { createLeftAnchorWidget } from './createAnchorDecorationWidgets';
 import { createChangedRowDecorationWidgets } from './createChangedRowDecorationWidgets';
+import { createContributorTagHost, unmountContributorTag } from './createContributorTagWidget';
 import { buildDiffDecorationSpec, buildAnchorDecorationKey } from './decorationKeys';
 import { findSafeInsertPos } from './utils/findSafeInsertPos';
 import { wrapBlockNodeView, injectInnerWrapper, createContentWrapper } from './utils/wrapBlockNodeView';
@@ -89,6 +90,7 @@ const createTableCellContentWidgets = ({
  * that is not in the current document.
  */
 export const createNodeChangedDecorationWidget = ({
+  attributionKey,
   change,
   doc,
   nodeViewSerializer,
@@ -98,13 +100,15 @@ export const createNodeChangedDecorationWidget = ({
   activeIndexPos,
   // This is false by default as this is generally used to show deleted content
   isInserted = false,
+  showContributorTags = false,
   showIndicators = false,
   // When true, render the deleted content *after* (below) the new content instead of
   // before it. Used for `smart` node-level changes so the deleted node appears beneath
   // its replacement (gray + strikethrough).
   placeBelow = false,
   diffType,
-  hideAddedDiffsUnderline = false
+  hideAddedDiffsUnderline = false,
+  tagMountContext
 }) => {
   var _slice$content, _slice$content2, _slice$content2$first, _slice$content3, _slice$content3$first, _$safeInsertPos$nodeB, _slice$content$firstC, _newDoc$firstChild, _slice$content$firstC2;
   const slice = doc.slice(change.fromA, change.toA);
@@ -196,7 +200,9 @@ export const createNodeChangedDecorationWidget = ({
       subtree: true
     });
   }
-  const diffId = crypto.randomUUID();
+  // Derived from the deleted range so it survives a recalculation — see the same reasoning in
+  // `createInlineChangedDecoration`.
+  const diffId = showContributorTags ? `widget-${change.fromA}-${change.toA}` : crypto.randomUUID();
   const decorations = [];
   const replacementNode = newDoc.nodeAt(change.fromB);
   const firstReplacedNode = slice.content.firstChild;
@@ -313,24 +319,48 @@ export const createNodeChangedDecorationWidget = ({
     }
   });
   dom.setAttribute('data-testid', 'show-diff-deleted-decoration');
+
+  // Needed even when the indicator bar is off, because a contributor tag also anchors against the
+  // widget.
+  if ((showIndicators || showContributorTags) && isExtendedEnabled(diffType)) {
+    dom.style.setProperty('anchor-name', `--${buildAnchorDecorationKey({
+      diffId
+    })}`);
+  }
+
+  // Taken down in the widget's `destroy` below: `dom` is rebuilt on every recalculation, so the tag
+  // mounted into it must not outlive the copy ProseMirror is drawing.
+  let tagMount;
+  if (showContributorTags) {
+    // Lets the contributor tag find the deleted content on hover.
+    dom.setAttribute('data-diff-id', diffId);
+
+    // Hosted at the start of the deleted run rather than on `dom` itself: `dom` is inline, so once
+    // the deleted content wraps its box is the union of its line fragments.
+    const tagHost = createContributorTagHost(diffId, tagMountContext);
+    if (tagHost) {
+      dom.prepend(tagHost.host);
+      tagMount = tagHost.mount;
+    }
+  }
   if (showIndicators && isExtendedEnabled(diffType)) {
     const leftAnchor = createLeftAnchorWidget({
       doc: newDoc,
       from: safeInsertPos,
       diffId
     });
-    dom.style.setProperty('anchor-name', `--${buildAnchorDecorationKey({
-      diffId
-    })}`);
     if (leftAnchor) {
       decorations.push(leftAnchor);
     }
   }
   decorations.push(Decoration.widget(safeInsertPos, dom, {
     ...buildDiffDecorationSpec({
+      attributionKey,
+      colorScheme,
       decorationType: 'widget',
       diffId,
       isActive,
+      isInserted,
       diffType,
       ...(isExtendedEnabled(diffType) && {
         // placeBelow anchors at the end of the new content, so render on the
@@ -347,7 +377,9 @@ export const createNodeChangedDecorationWidget = ({
     }),
     destroy: () => {
       var _constrainMediaObserv2;
-      return (_constrainMediaObserv2 = constrainMediaObserver) === null || _constrainMediaObserv2 === void 0 ? void 0 : _constrainMediaObserv2.disconnect();
+      (_constrainMediaObserv2 = constrainMediaObserver) === null || _constrainMediaObserv2 === void 0 ? void 0 : _constrainMediaObserv2.disconnect();
+      unmountContributorTag(tagMount);
+      tagMount = undefined;
     }
   }));
 

package/dist/es2019/pm-plugins/decorations/decorationKeys.js

@@ -1,12 +1,12 @@
 import { isExtendedEnabled } from '../isExtendedEnabled';
-
 /**
  * Decoration families produced by the show-diff plugin.
  * Each family owns its own key space and spec shape.
  */
 export const DecorationFamily = {
   diff: 'diff',
-  anchor: 'anchor'
+  anchor: 'anchor',
+  contributorTag: 'contributor-tag'
 };
 export const AnchorTypeKey = {
   from: 'from',
@@ -14,6 +14,12 @@ export const AnchorTypeKey = {
   left: 'left',
   docMargin: 'doc-margin'
 };
+
+/**
+ * The host widget one contributor tag renders into. Its own family, so the tag never reaches the
+ * consumers that read diff decorations — change counting, navigation and `getDeletedWidgets`.
+ */
+
 /**
  * The diff-decoration kinds produced by the show-diff plugin. Each value is
  * the leading segment of the generated key, so a diff decoration's kind can be
@@ -49,9 +55,12 @@ export const buildDiffDecorationKey = ({
   return isActive !== undefined ? `${decorationKeyPrefix}-${isActive ? 'active' : 'inactive'}` : decorationKeyPrefix;
 };
 export const buildDiffDecorationSpec = ({
+  attributionKey,
+  colorScheme,
   decorationType,
   diffId,
   isActive,
+  isInserted,
   nodeName,
   side,
   diffType
@@ -65,6 +74,19 @@ export const buildDiffDecorationSpec = ({
     isActive,
     diffType
   }),
+  ...(attributionKey ? {
+    attributionKey
+  } : {}),
+  // Only alongside an attribution key, so the spec shape is unchanged when the gate is off.
+  ...(attributionKey && isActive !== undefined ? {
+    isActive
+  } : {}),
+  ...(attributionKey && isInserted !== undefined ? {
+    isInserted
+  } : {}),
+  ...(attributionKey && colorScheme ? {
+    colorScheme
+  } : {}),
   ...(nodeName ? {
     nodeName
   } : {}),
@@ -103,6 +125,12 @@ export function buildAnchorDecorationSpec({
     } : {})
   };
 }
+export const buildContributorTagDecorationSpec = diffId => ({
+  decorationFamily: DecorationFamily.contributorTag,
+  diffId,
+  // Stable across recalculations, so ProseMirror keeps the host element the tag is portalled into.
+  key: `${DecorationFamily.contributorTag}-${diffId}`
+});
 export const isDiffDecorationSpec = spec => Boolean(spec && typeof spec === 'object' && 'decorationFamily' in spec && spec.decorationFamily === DecorationFamily.diff);
 export const isAnchorDecorationSpec = spec => Boolean(spec && typeof spec === 'object' && 'decorationFamily' in spec && spec.decorationFamily === DecorationFamily.anchor);
 export const isDiffDecoration = decoration => isDiffDecorationSpec(decoration.spec);

package/dist/es2019/pm-plugins/decorations/extractContributorTags.js

@@ -0,0 +1,101 @@
+import { isDiffDecoration, isDiffDecorationSpec } from './decorationKeys';
+
+/**
+ * Diff kinds that expose an anchor a tag can be pinned to: `inline` is added/changed content,
+ * `widget` is deleted content. Block diffs carry no attribution.
+ */
+const TAGGABLE_DECORATION_TYPES = new Set(['inline', 'widget']);
+
+/** The connection is an internal key, so it is dropped on the way to the tag. */
+const toTagContributor = ({
+  connectedToKey: _connectedToKey,
+  ...tagContributor
+}) => tagContributor;
+/**
+ * Whether a deleted-content widget belongs to the same change as an inline decoration. A replacement
+ * renders both — the inserted text inline, the deleted text as a widget anchored to one end of that
+ * inline range — and the two must not each claim a tag.
+ */
+const isSameChange = (widget, inline) => widget.spec.attributionKey === inline.spec.attributionKey && widget.from >= inline.from && widget.from <= inline.to;
+
+/**
+ * One model per diff decoration whose attribution resolves to a supplied contributor; anything
+ * unattributed, untaggable or unresolved is skipped. A replacement's two decorations are collapsed
+ * into the single inline tag — see `isSameChange`.
+ */
+export const extractContributorTags = (decorations, contributors) => {
+  if (!contributors) {
+    return [];
+  }
+  const targets = [];
+  for (const decoration of decorations.find(undefined, undefined, isDiffDecorationSpec)) {
+    if (!isDiffDecoration(decoration)) {
+      continue;
+    }
+    const {
+      spec
+    } = decoration;
+    if (!spec.attributionKey || !TAGGABLE_DECORATION_TYPES.has(spec.decorationType)) {
+      continue;
+    }
+    const contributor = contributors[spec.attributionKey];
+    if (!contributor) {
+      continue;
+    }
+    targets.push({
+      contributor,
+      decoration
+    });
+  }
+
+  // The inline decoration keeps the tag: it captions content still in the document.
+  const inlineTargets = targets.filter(({
+    decoration
+  }) => decoration.spec.decorationType === 'inline');
+  const linkedDiffIds = new Map();
+  const folded = new Set();
+  for (const target of targets) {
+    var _linkedDiffIds$get;
+    if (target.decoration.spec.decorationType !== 'widget') {
+      continue;
+    }
+    const host = inlineTargets.find(({
+      decoration
+    }) => isSameChange(target.decoration, decoration));
+    if (!host) {
+      continue;
+    }
+    folded.add(target);
+    const hostDiffId = host.decoration.spec.diffId;
+    linkedDiffIds.set(hostDiffId, [...((_linkedDiffIds$get = linkedDiffIds.get(hostDiffId)) !== null && _linkedDiffIds$get !== void 0 ? _linkedDiffIds$get : []), target.decoration.spec.diffId]);
+  }
+  return targets.filter(target => !folded.has(target)).map(({
+    contributor,
+    decoration: {
+      spec
+    }
+  }) => {
+    const connected = contributor.connectedToKey ? contributors[contributor.connectedToKey] : undefined;
+    const connectedContributor = connected ? toTagContributor(connected) : undefined;
+    const linked = linkedDiffIds.get(spec.diffId);
+    return {
+      contributor: toTagContributor(contributor),
+      diffId: spec.diffId,
+      ...(connectedContributor ? {
+        connectedContributor
+      } : {}),
+      ...(spec.colorScheme ? {
+        colorScheme: spec.colorScheme
+      } : {}),
+      ...(spec.isActive !== undefined ? {
+        isActive: spec.isActive
+      } : {}),
+      ...(spec.isInserted !== undefined ? {
+        isInserted: spec.isInserted
+      } : {}),
+      ...(linked ? {
+        linkedDiffIds: linked
+      } : {})
+    };
+  });
+};

package/dist/es2019/pm-plugins/main.js

@@ -5,13 +5,31 @@ import { PluginKey } from '@atlaskit/editor-prosemirror/state';
 import { Step as ProseMirrorStep } from '@atlaskit/editor-prosemirror/transform-override';
 import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
 import { calculateDiffDecorations } from './calculateDiff/calculateDiffDecorations';
+import { isDiffDecoration, isDiffDecorationSpec } from './decorations/decorationKeys';
 import { enforceCustomStepRegisters } from './enforceCustomStepRegisters';
 import { getScrollableDecorations } from './getScrollableDecorations';
 import { getDefaultDiffType, isExtendedEnabled } from './isExtendedEnabled';
 import { NodeViewSerializer } from './NodeViewSerializer';
 import { scrollToDecoration } from './scrollToDiff';
 export const showDiffPluginKey = new PluginKey('showDiffPlugin');
-export const createPlugin = (config, getIntl, api, onEditorView) => {
+/**
+ * Tags whose diff decoration survived the transaction. A document change can map a decoration away
+ * without any `showDiff`/`hideDiff` following it, and a tag left behind has no host to render into.
+ * Returns the given array when every tag is still live.
+ */
+const dropOrphanedContributorTags = (contributorTags, decorations) => {
+  if (!(contributorTags !== null && contributorTags !== void 0 && contributorTags.length)) {
+    return contributorTags;
+  }
+  const liveDiffIds = new Set(decorations.find(undefined, undefined, isDiffDecorationSpec).filter(isDiffDecoration).map(({
+    spec
+  }) => spec.diffId));
+  const liveTags = contributorTags.filter(({
+    diffId
+  }) => liveDiffIds.has(diffId));
+  return liveTags.length === contributorTags.length ? contributorTags : liveTags;
+};
+export const createPlugin = (config, getIntl, api, portalProviderAPI, onEditorView) => {
   enforceCustomStepRegisters();
   const nodeViewSerializer = new NodeViewSerializer({});
   const setNodeViewSerializer = editorView => {
@@ -19,6 +37,23 @@ export const createPlugin = (config, getIntl, api, onEditorView) => {
       editorView
     });
   };
+
+  /**
+   * This editor's own content root. The contributor tags scope every DOM lookup to it, so they take
+   * it from the view the plugin was mounted on rather than resolving `.ProseMirror` by class name
+   * from a decoration — a class this package does not own, and one whose nearest match is the wrong
+   * editor whenever editors are nested. A getter because the view arrives with the ProseMirror view
+   * lifecycle, which decorations are calculated independently of.
+   */
+  let currentEditorView;
+  const tagMountContext = portalProviderAPI ? {
+    api,
+    getEditorRoot: () => {
+      var _currentEditorView$do, _currentEditorView;
+      return (_currentEditorView$do = (_currentEditorView = currentEditorView) === null || _currentEditorView === void 0 ? void 0 : _currentEditorView.dom) !== null && _currentEditorView$do !== void 0 ? _currentEditorView$do : null;
+    },
+    portalProviderAPI
+  } : undefined;
   return new SafePlugin({
     key: showDiffPluginKey,
     state: {
@@ -56,6 +91,7 @@ export const createPlugin = (config, getIntl, api, onEditorView) => {
             };
             // Calculate and store decorations in state
             const {
+              contributorTags,
               decorations,
               diffDescriptors
             } = calculateDiffDecorations({
@@ -66,6 +102,7 @@ export const createPlugin = (config, getIntl, api, onEditorView) => {
               intl: getIntl(),
               activeIndexPos: newPluginState.activeIndexPos,
               api,
+              tagMountContext,
               ...(isExtendedEnabled((_newPluginState = newPluginState) === null || _newPluginState === void 0 ? void 0 : _newPluginState.diffType) ? {
                 isInverted: (_newPluginState2 = newPluginState) === null || _newPluginState2 === void 0 ? void 0 : _newPluginState2.isInverted,
                 diffType: (_newPluginState3 = newPluginState) === null || _newPluginState3 === void 0 ? void 0 : _newPluginState3.diffType,
@@ -79,6 +116,7 @@ export const createPlugin = (config, getIntl, api, onEditorView) => {
             });
             // Update the decorations and their ids
             newPluginState.decorations = decorations;
+            newPluginState.contributorTags = contributorTags;
             if (isExtendedEnabled((_newPluginState0 = newPluginState) === null || _newPluginState0 === void 0 ? void 0 : _newPluginState0.diffType)) {
               newPluginState.diffDescriptors = diffDescriptors;
             }
@@ -89,6 +127,7 @@ export const createPlugin = (config, getIntl, api, onEditorView) => {
               decorations: DecorationSet.empty,
               isDisplayingChanges: false,
               activeIndex: undefined,
+              contributorTags: [],
               /**
                * Reset isInverted & diffType state when hiding diffs
                * Otherwise this should persist for the diff-showing session
@@ -132,6 +171,7 @@ export const createPlugin = (config, getIntl, api, onEditorView) => {
               };
               // Recalculate decorations with the new active index
               const {
+                contributorTags: updatedContributorTags,
                 decorations: updatedDecorations,
                 diffDescriptors: updatedDiffDescriptors
               } = calculateDiffDecorations({
@@ -142,6 +182,7 @@ export const createPlugin = (config, getIntl, api, onEditorView) => {
                 intl: getIntl(),
                 activeIndexPos: newPluginState.activeIndexPos,
                 api,
+                tagMountContext,
                 ...(isExtendedEnabled(newPluginState.diffType) ? {
                   isInverted: newPluginState.isInverted,
                   diffType: newPluginState.diffType,
@@ -154,6 +195,7 @@ export const createPlugin = (config, getIntl, api, onEditorView) => {
                 } : {})
               });
               newPluginState.decorations = updatedDecorations;
+              newPluginState.contributorTags = updatedContributorTags;
               if (isExtendedEnabled(newPluginState.diffType)) {
                 newPluginState.diffDescriptors = updatedDiffDescriptors;
               }
@@ -165,14 +207,20 @@ export const createPlugin = (config, getIntl, api, onEditorView) => {
             };
           }
         }
-        return {
+        const mappedDecorations = newPluginState.decorations.map(tr.mapping, tr.doc);
+        const nextState = {
           ...newPluginState,
-          decorations: newPluginState.decorations.map(tr.mapping, tr.doc)
+          decorations: mappedDecorations
         };
+        if (tr.docChanged) {
+          nextState.contributorTags = dropOrphanedContributorTags(newPluginState.contributorTags, mappedDecorations);
+        }
+        return nextState;
       }
     },
     view(editorView) {
       setNodeViewSerializer(editorView);
+      currentEditorView = editorView;
       onEditorView === null || onEditorView === void 0 ? void 0 : onEditorView(editorView);
       let isFirst = true;
       let previousActiveIndex;
@@ -224,6 +272,7 @@ export const createPlugin = (config, getIntl, api, onEditorView) => {
           var _cancelPendingScrollT3;
           (_cancelPendingScrollT3 = cancelPendingScrollToDecoration) === null || _cancelPendingScrollT3 === void 0 ? void 0 : _cancelPendingScrollT3();
           cancelPendingScrollToDecoration = null;
+          currentEditorView = undefined;
           onEditorView === null || onEditorView === void 0 ? void 0 : onEditorView(undefined);
         }
       };

package/dist/es2019/pm-plugins/resolveDiffContributors.js

@@ -0,0 +1,128 @@
+import { getAttributionKey } from './decorations/colorSchemes/attributions';
+
+/** A brand name, so a literal rather than a translated message. */
+const ROVO_AGENT_NAME = 'Rovo';
+
+/** `agentType` values that render as "Rovo" rather than as a generic external agent. */
+const ROVO_AGENT_TYPES = new Set(['convo-ai', 'rovo_chat']);
+const hasAgentIdentity = attribution => {
+  var _attribution$agentId, _attribution$agentTyp;
+  return Boolean(((_attribution$agentId = attribution.agentId) === null || _attribution$agentId === void 0 ? void 0 : _attribution$agentId.trim()) || ((_attribution$agentTyp = attribution.agentType) === null || _attribution$agentTyp === void 0 ? void 0 : _attribution$agentTyp.trim()));
+};
+const toProfilesByAccountId = profiles => {
+  const profilesByAccountId = new Map();
+  profiles === null || profiles === void 0 ? void 0 : profiles.forEach(profile => {
+    // Trimmed to match how attribution ids are keyed, so the two sides compare like for like.
+    const accountId = profile.accountId.trim();
+    if (accountId && !profilesByAccountId.has(accountId)) {
+      profilesByAccountId.set(accountId, profile);
+    }
+  });
+  return profilesByAccountId;
+};
+const resolveUser = (userId, profilesByAccountId) => {
+  const profile = profilesByAccountId.get(userId);
+  return profile ? {
+    avatarUrl: profile.avatarUrl,
+    kind: 'user',
+    name: profile.name
+  } : undefined;
+};
+
+/** An agent always resolves: its profile, else "Rovo" for a first-party type, else external. */
+const resolveAgent = (attribution, profilesByAccountId) => {
+  var _attribution$agentId2, _attribution$agentTyp2;
+  const agentId = (_attribution$agentId2 = attribution.agentId) === null || _attribution$agentId2 === void 0 ? void 0 : _attribution$agentId2.trim();
+  const agentProfile = agentId ? profilesByAccountId.get(agentId) : undefined;
+  if (agentProfile) {
+    return {
+      agentKind: 'identified',
+      avatarUrl: agentProfile.avatarUrl,
+      kind: 'agent',
+      name: agentProfile.name
+    };
+  }
+  const agentType = (_attribution$agentTyp2 = attribution.agentType) === null || _attribution$agentTyp2 === void 0 ? void 0 : _attribution$agentTyp2.trim().toLowerCase();
+
+  // An empty name lets the tag fall back to its own localised "External agent" label.
+  return agentType && ROVO_AGENT_TYPES.has(agentType) ? {
+    agentKind: 'rovo',
+    kind: 'agent',
+    name: ROVO_AGENT_NAME
+  } : {
+    agentKind: 'external',
+    kind: 'agent',
+    name: ''
+  };
+};
+
+/**
+ * One contributor per distinct actor behind the attributed steps, resolved against the identities
+ * the consumer supplied. Returns `undefined` if any actor cannot be named: a half-credited diff
+ * reads as "nobody touched this", so the whole list is dropped and the plain diff renders instead.
+ */
+export const resolveDiffContributors = (stepsWithAttribution, profiles) => {
+  const profilesByAccountId = toProfilesByAccountId(profiles);
+  const contributors = [];
+  /** Keyed as the plugin keys changes, so no two entries can collapse onto one another. */
+  const creditedActors = new Set();
+  for (const {
+    stepAttribution
+  } of stepsWithAttribution) {
+    var _stepAttribution$user;
+    // An attribution naming nobody (e.g. one carrying only `wasOffline`) has nobody to credit.
+    const actor = stepAttribution ? getAttributionKey(stepAttribution) : undefined;
+    if (!stepAttribution || !actor || creditedActors.has(actor)) {
+      continue;
+    }
+    const userId = (_stepAttribution$user = stepAttribution.userId) === null || _stepAttribution$user === void 0 ? void 0 : _stepAttribution$user.trim();
+    if (hasAgentIdentity(stepAttribution)) {
+      const agent = resolveAgent(stepAttribution, profilesByAccountId);
+      if (!userId) {
+        // Agent mode: the agent acted on its own, so it is credited on its own.
+        contributors.push({
+          ...agent,
+          attribution: stepAttribution
+        });
+        creditedActors.add(actor);
+        continue;
+      }
+
+      // User-invoked agent: credit both actors and link the agent back to the invoking user.
+      const invokingUser = {
+        userId
+      };
+      const user = resolveUser(userId, profilesByAccountId);
+      if (!user) {
+        return undefined;
+      }
+
+      // Skipped if the invoking user's own step already credited them.
+      const invokingUserActor = getAttributionKey(invokingUser);
+      if (invokingUserActor && !creditedActors.has(invokingUserActor)) {
+        contributors.push({
+          ...user,
+          attribution: invokingUser
+        });
+        creditedActors.add(invokingUserActor);
+      }
+      contributors.push({
+        ...agent,
+        attribution: stepAttribution,
+        connectedTo: invokingUser
+      });
+      creditedActors.add(actor);
+      continue;
+    }
+    const user = userId ? resolveUser(userId, profilesByAccountId) : undefined;
+    if (!user) {
+      return undefined;
+    }
+    contributors.push({
+      ...user,
+      attribution: stepAttribution
+    });
+    creditedActors.add(actor);
+  }
+  return contributors.length > 0 ? contributors : undefined;
+};