@atlaskit/editor-plugin-show-diff 16.1.0 → 16.2.0

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

@@ -6,7 +6,11 @@ import { createLeftAnchorWidget } from './createAnchorDecorationWidgets';
 import { createChangedRowDecorationWidgets } from './createChangedRowDecorationWidgets';
 import { createContributorTagHost, unmountContributorTag } from './createContributorTagWidget';
 import { buildDiffDecorationSpec, buildAnchorDecorationKey, scrollMarginTopValue } from './decorationKeys';
+import { absorbFirstChildMarginReset } from './utils/absorbFirstChildMarginReset';
+import { createMarginAbsorber } from './utils/createMarginAbsorber';
+import { createNodeShapedMarginSpacer } from './utils/createNodeShapedMarginSpacer';
 import { findSafeInsertPos } from './utils/findSafeInsertPos';
+import { safeResolve } from './utils/safeResolve';
 import { wrapBlockNodeView, injectInnerWrapper, createContentWrapper } from './utils/wrapBlockNodeView';
 const isHeadingLevel = level => typeof level === 'number' && level >= 1 && level <= 6;
 
@@ -174,6 +178,14 @@ export const createNodeChangedDecorationWidget = ({
   // For non-table content, use the existing span wrapper approach
   const dom = document.createElement('span');
   const $safeInsertPos = newDoc.resolve(safeInsertPos);
+
+  // Whether the widget renders above the very start of its parent's content — the document, a
+  // layout column, a table cell, a panel.
+  //
+  // `parentOffset === 0` is the whole test on the position side: prosemirror-view paints every
+  // widget at a position before the node starting there, so a leading widget at the parent's start
+  // always renders above its content.
+  const isVisuallyFirstInParent = !placeBelow && $safeInsertPos.parentOffset === 0;
   const isTopLevelInsert = $safeInsertPos.depth === 0;
   const hasPreviousBlock = ((_$safeInsertPos$nodeB = $safeInsertPos.nodeBefore) === null || _$safeInsertPos$nodeB === void 0 ? void 0 : _$safeInsertPos$nodeB.isBlock) === true;
   const isFirstDocHeadingReplacement = isExtendedEnabled(diffType) && !placeBelow && change.fromB === 0 && ((_slice$content$firstC = slice.content.firstChild) === null || _slice$content$firstC === void 0 ? void 0 : _slice$content$firstC.type.name) === 'heading' && ((_newDoc$firstChild = newDoc.firstChild) === null || _newDoc$firstChild === void 0 ? void 0 : _newDoc$firstChild.type.name) === 'heading';
@@ -225,6 +237,20 @@ export const createNodeChangedDecorationWidget = ({
   const firstReplacedNode = slice.content.firstChild;
   const lastReplacedNode = slice.content.lastChild;
   const showDiffPatch1 = fg('platform_editor_ai_show_diff_patch_1');
+  // Whether the slice's outermost textblocks still hold all of their original content.
+  //
+  // `openStart`/`openEnd` say whether the cut landed inside a block, but not whether it took
+  // any text with it — a deletion stopping exactly at a block's content boundary is still
+  // reported as open. Resolving the change's own ends separates the two, so a block whose text
+  // survived intact can render as a block even though its boundary was open.
+  //
+  // Both resolves sit behind the gate that consumes them, so this adds no position arithmetic to
+  // the ungated path, and an unresolvable position degrades to the `openStart`/`openEnd` test on
+  // its own — the block is then treated as partial, which is what it rendered as before the gate.
+  const $changeFromA = fg('platform_editor_ai_show_diff_patch_2') ? safeResolve(doc, change.fromA) : null;
+  const $changeToA = fg('platform_editor_ai_show_diff_patch_2') ? safeResolve(doc, change.toA) : null;
+  const isFirstNodeContentComplete = slice.openStart === 0 || ($changeFromA === null || $changeFromA === void 0 ? void 0 : $changeFromA.parentOffset) === 0;
+  const isLastNodeContentComplete = slice.openEnd === 0 || $changeToA !== null && $changeToA.parentOffset === $changeToA.parent.content.size;
   const isCompleteSameTypeReplacement = slice.content.childCount === 1 && firstReplacedNode !== null && replacementNode !== null && firstReplacedNode.type === replacementNode.type && replacementNode.nodeSize === change.toB - change.fromB;
 
   /*
@@ -237,10 +263,16 @@ export const createNodeChangedDecorationWidget = ({
     const isLast = lastReplacedNode === node;
     const isOpenAtSliceBoundary = isFirst && slice.openStart > 0 || isLast && slice.openEnd > 0;
     const shouldPreserveCompleteMultiInlineBlock = showDiffPatch1 && node.isBlock && node.type.inlineContent && node.content.childCount > 1 && !isOpenAtSliceBoundary && isCompleteSameTypeReplacement;
+    // A textblock is otherwise serialized as its inline content only, with no `<p>`/`<h2>` wrapper.
+    // That is right when the diff cuts into an existing block — the deleted text belongs on the same
+    // line as the text that replaced it — but when the whole block went away it drops the very
+    // element that carries the block's margin, so the deleted block renders flush against its
+    // neighbours. Only the first and last children can be partial; middle ones are always complete.
+    const shouldRenderAsBlockNode = fg('platform_editor_ai_show_diff_patch_2') && node.isTextblock && (!isFirst || isFirstNodeContentComplete) && (!isLast || isLastNodeContentComplete);
 
     // Helper function to handle multiple child nodes
     const handleMultipleChildNodes = node => {
-      if (!shouldPreserveCompleteMultiInlineBlock && node.content.childCount > 1 && node.type.inlineContent) {
+      if (!shouldPreserveCompleteMultiInlineBlock && !shouldRenderAsBlockNode && node.content.childCount > 1 && node.type.inlineContent) {
         node.content.forEach(childNode => {
           const childNodeView = serializer.tryCreateNodeView(childNode);
           if (childNodeView) {
@@ -270,7 +302,7 @@ export const createNodeChangedDecorationWidget = ({
     if (handleMultipleChildNodes(node)) {
       return;
     }
-    if (shouldPreserveCompleteMultiInlineBlock) {
+    if (shouldPreserveCompleteMultiInlineBlock || shouldRenderAsBlockNode) {
       fallbackSerialization = () => serializer.serializeNode(node);
     } else if ((isFirst || isLast && slice.content.childCount > 2) && hasInlineContent) {
       fallbackSerialization = () => serializer.serializeFragment(node.content);
@@ -341,6 +373,21 @@ export const createNodeChangedDecorationWidget = ({
     dom.style.setProperty('scroll-margin-top', scrollMarginTopValue);
   }
 
+  // A block node serialized into the widget is the widget's first child, and the editor's
+  // first-child reset is written against the parent element rather than the document position — so
+  // it zeroes the margin the block wrapper was kept for in the first place.
+  //
+  // Only away from the parent's start. There the reset is the correct outcome: the widget is the
+  // first thing in the document, column, cell or panel, and a leading gap above it would be wrong.
+  // The margin that matters at that position belongs to the node *below* the widget, which the
+  // shaped spacer pair supplies instead.
+  if (fg('platform_editor_ai_show_diff_patch_2') && !isVisuallyFirstInParent) {
+    absorbFirstChildMarginReset({
+      dom,
+      testId: 'show-diff-widget-margin-absorber'
+    });
+  }
+
   // Needed even when the indicator bar is off, because a contributor tag also anchors against the
   // widget.
   if ((showIndicators || showContributorTags) && isExtendedEnabled(diffType)) {
@@ -410,7 +457,40 @@ export const createNodeChangedDecorationWidget = ({
   const isPureDeletion = change.fromB === change.toB;
   const isSingleBlock = slice.content.childCount === 1 && ((_slice$content$firstC2 = slice.content.firstChild) === null || _slice$content$firstC2 === void 0 ? void 0 : _slice$content$firstC2.isBlock);
   const isDiffWidgetAtStartOfDoc = $safeInsertPos.depth === 0 && $safeInsertPos.index(0) === 0;
-  if (isDiffWidgetAtStartOfDoc && isSingleBlock && isPureDeletion && isExtendedEnabled(diffType)) {
+
+  // A node at the start of its parent has its top margin reset, so a diff widget rendered above
+  // it sits flush against it. This applies wherever that parent is — the document, a layout
+  // column, a table cell — so it is decided from the anchor rather than from the document root
+  // (see `isVisuallyFirstInParent` above).
+  //
+  // Away from the parent's start the node below keeps its own margin, and it is the block *inside*
+  // the widget that loses one — handled by `absorbFirstChildMarginReset` above, not here.
+  const nodeAfterWidget = $safeInsertPos.nodeAfter;
+  if (fg('platform_editor_ai_show_diff_patch_2') && isExtendedEnabled(diffType) && isVisuallyFirstInParent && nodeAfterWidget) {
+    const shapedSpacer = createNodeShapedMarginSpacer({
+      node: nodeAfterWidget,
+      serializer,
+      testId: 'show-diff-shaped-margin-spacer'
+    });
+    if (shapedSpacer) {
+      // Two elements, because the two families of reset have to be handled differently. The
+      // absorber takes the document-level adjacent-sibling reset for a leading widget, whose
+      // `!important` would otherwise zero the shaped spacer's margin; the shaped spacer, now one
+      // position further along, is out of that rule's reach and keeps the margin it supplies.
+      // Inside containers the counting selectors skip both, so only the shaped one has an effect.
+      //
+      // Sides order the widgets against each other only — both still paint before the real node.
+      decorations.push(Decoration.widget(safeInsertPos, createMarginAbsorber({
+        testId: 'show-diff-margin-absorber'
+      }), {
+        side: 0
+      }));
+      decorations.push(Decoration.widget(safeInsertPos, shapedSpacer, {
+        side: 1
+      }));
+    }
+  }
+  if (!fg('platform_editor_ai_show_diff_patch_2') && isDiffWidgetAtStartOfDoc && isSingleBlock && isPureDeletion && isExtendedEnabled(diffType)) {
     const followingNode = $safeInsertPos.nodeAfter;
     const headingLevel = (followingNode === null || followingNode === void 0 ? void 0 : followingNode.type.name) === 'heading' ? followingNode.attrs.level : undefined;
     if (isHeadingLevel(headingLevel)) {

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

@@ -34,6 +34,12 @@ const leadsReplacement = widget => fg('confluence_ncs_step_diffing_version_histo
  */
 const isSameBlockChange = (inner, block) => inner.spec.attributionKey === block.spec.attributionKey && (block.from <= inner.from && inner.to <= block.to || inner.from <= block.from && block.to <= inner.to);
 
+/**
+ * Whether `outer` is the box `inner` sits in, for one contributor. Nested blocks they inserted read
+ * as one change, so only the outermost keeps a tag (EDITOR-8932).
+ */
+const containsBlock = (outer, inner) => outer.spec.attributionKey === inner.spec.attributionKey && outer.from <= inner.from && inner.to <= outer.to && outer.to - outer.from > inner.to - inner.from;
+
 /**
  * Which of two changes in the same range leads, and so is the one a tag captions. Position first,
  * then `side`, since deleted content shares its `from` with the content that replaced it and paints
@@ -52,6 +58,15 @@ const containedBy = (targets, {
   decoration
 }) => from <= decoration.from && decoration.to <= to).sort(byLeadingPosition);
 
+/**
+ * The stop a target is stepped to by: the narrowest one that wholly covers it. A stop's range is
+ * the union of the decorations grouped into it, so one inserted run's inline highlight stretches
+ * its stop over every block the run spans — including blocks that are a stop of their own. Picking
+ * the narrowest keeps each of those blocks in the stop that actually reaches it, rather than
+ * letting the widest stop claim them all and fold away every tag but the first (EDITOR-8932).
+ */
+const owningStop = (target, stops) => stops.reduce((narrowest, stop) => stop.from <= target.decoration.from && target.decoration.to <= stop.to && (narrowest === undefined || stop.to - stop.from < narrowest.to - narrowest.from) ? stop : narrowest, undefined);
+
 /**
  * The one tag a navigation step reveals. `spec.isActive` is no use here: it covers everything the
  * group's union range touches, so several tags revealed over each other (EDITOR-8971). Hence
@@ -108,6 +123,10 @@ export const extractContributorTags = (decorations, contributors, activeIndexPos
   }) => decoration.spec.decorationType === 'widget');
   const linkedDiffIds = new Map();
   const folded = new Set();
+
+  /**
+   * A folded target keeps no tag of its own — it becomes a hover target of the host instead.
+   */
   const fold = (host, target) => {
     var _linkedDiffIds$get, _linkedDiffIds$get2;
     folded.add(target);
@@ -158,20 +177,54 @@ export const extractContributorTags = (decorations, contributors, activeIndexPos
     }
   }
 
+  // A nested block folds into the outermost one of the same contributor, so nesting adds no tags.
+  if (fg('confluence_ncs_step_diffing_version_history')) {
+    const blocksByContributor = new Map();
+    for (const target of blockTargets) {
+      var _target$decoration$sp, _blocksByContributor$;
+      const key = (_target$decoration$sp = target.decoration.spec.attributionKey) !== null && _target$decoration$sp !== void 0 ? _target$decoration$sp : '';
+      blocksByContributor.set(key, [...((_blocksByContributor$ = blocksByContributor.get(key)) !== null && _blocksByContributor$ !== void 0 ? _blocksByContributor$ : []), target]);
+    }
+    for (const contributorBlocks of blocksByContributor.values()) {
+      // Block ranges nest rather than partially overlap, so ascending `from` then descending `to`
+      // reaches every block after the ones containing it. A stack of the blocks still open at
+      // this position then yields each block's container in one pass, rather than rescanning
+      // every block for the widest that contains it.
+      const nested = [...contributorBlocks].sort((left, right) => left.decoration.from - right.decoration.from || right.decoration.to - left.decoration.to);
+      const open = [];
+      for (const target of nested) {
+        while (open.length > 0 && !containsBlock(open[open.length - 1].decoration, target.decoration)) {
+          open.pop();
+        }
+        // Outermost first, so the bottom of the stack is the block the tag survives on.
+        if (open.length > 0) {
+          fold(open[0], target);
+        }
+        open.push(target);
+      }
+    }
+  }
+
   // One tag per contributor per navigation stop. The folds above only catch a replacement's two
   // halves and a block's own highlights; two of one contributor's changes that merely touch are a
   // single stop (`groupTouchingDecorations`) yet kept a tag each, so the stop's trailing tag was
   // drawn but could never be stepped to (EDITOR-8971). It folds into the leading tag of its
   // contributor, staying a hover target. Contributors are kept apart: a stop spanning two of them
   // still captions each, rather than crediting one for the other's change.
-  for (const stop of stops !== null && stops !== void 0 ? stops : []) {
-    const byContributor = new Map();
-    for (const target of containedBy(targets.filter(target => !folded.has(target)), stop)) {
-      var _target$decoration$sp, _byContributor$get;
-      const key = (_target$decoration$sp = target.decoration.spec.attributionKey) !== null && _target$decoration$sp !== void 0 ? _target$decoration$sp : '';
-      byContributor.set(key, [...((_byContributor$get = byContributor.get(key)) !== null && _byContributor$get !== void 0 ? _byContributor$get : []), target]);
+  // Each target is counted against one stop only — see `owningStop`.
+  if (stops !== null && stops !== void 0 && stops.length) {
+    const byStopAndContributor = new Map();
+    for (const target of targets.filter(target => !folded.has(target))) {
+      var _target$decoration$sp2, _byStopAndContributor;
+      const stop = owningStop(target, stops);
+      if (stop === undefined) {
+        continue;
+      }
+      const key = `${stop.from}-${stop.to}|${(_target$decoration$sp2 = target.decoration.spec.attributionKey) !== null && _target$decoration$sp2 !== void 0 ? _target$decoration$sp2 : ''}`;
+      byStopAndContributor.set(key, [...((_byStopAndContributor = byStopAndContributor.get(key)) !== null && _byStopAndContributor !== void 0 ? _byStopAndContributor : []), target]);
     }
-    for (const [leader, ...trailing] of byContributor.values()) {
+    for (const members of byStopAndContributor.values()) {
+      const [leader, ...trailing] = [...members].sort(byLeadingPosition);
       trailing.forEach(target => fold(leader, target));
     }
   }

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

@@ -1,3 +1,4 @@
+import { agentBrandColorSchemes } from '@atlaskit/agent-color/agent-brand-color-schemes';
 import { convertToInlineCss } from '@atlaskit/editor-common/lazy-node-view';
 import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
 import { buildDeletedInlineStyleStandard, getDeletedInlineRevealColors, getInsertedInlineRevealColors } from './colorSchemes/factory';
@@ -96,6 +97,7 @@ export const resolveRevealStyle = ({
     return undefined;
   }
   const colors = getColorScheme(colorScheme);
+  const brand = isInserted && Object.prototype.hasOwnProperty.call(agentBrandColorSchemes, colors.insertColor) ? agentBrandColorSchemes[colors.insertColor] : undefined;
   const {
     background,
     border
@@ -106,7 +108,9 @@ export const resolveRevealStyle = ({
   });
   return {
     role: isInserted ? 'added' : 'deleted',
-    style: (isInserted || !includeDeletedTextStyle ? '' : deletedTextOnlyStyle(colors, isActive)) + revealBaseStyle + buildWipeableBackground(background) + buildRevealVariables({
+    style: (brand ? convertToInlineCss({
+      color: brand.text
+    }) : '') + (isInserted || !includeDeletedTextStyle ? '' : deletedTextOnlyStyle(colors, isActive)) + revealBaseStyle + buildWipeableBackground(background) + buildRevealVariables({
       background,
       border
     })

package/dist/es2019/pm-plugins/decorations/utils/absorbFirstChildMarginReset.js

@@ -0,0 +1,29 @@
+import { createBoxlessMarginAbsorber } from './createMarginAbsorber';
+
+/**
+ * Keeps a block node rendered inside a diff widget from losing its own top margin.
+ *
+ * The editor's leading-block margin reset is written against the parent element, not the document
+ * position, so it fires wherever a text block is a first child — including inside the widget's own
+ * `span`, which is what a whole-block deletion renders into. The widget then has no margin of its
+ * own, and the block sits flush against whatever is above it, regardless of where in the document
+ * the widget landed.
+ *
+ * The margin is not re-supplied; it is never taken away. Prepending an element the reset does not
+ * select moves the real block off the leading position, so the ordinary `.ProseMirror p`,
+ * `.ProseMirror h2` and similar rules go on applying to it untouched. That is why this needs no
+ * knowledge of which margin the block should have — unlike `createNodeShapedMarginSpacer`, which
+ * replicates a margin that has already been zeroed and cannot be read back.
+ *
+ * Unconditional, because the absorber generates no box: it costs nothing in a widget holding
+ * inline content, which the reset was never going to match anyway. Deciding here instead would mean
+ * restating the reset's selector list, and a copy of another package's CSS drifts silently.
+ */
+export const absorbFirstChildMarginReset = ({
+  dom,
+  testId
+}) => {
+  dom.prepend(createBoxlessMarginAbsorber({
+    testId
+  }));
+};

package/dist/es2019/pm-plugins/decorations/utils/createMarginAbsorber.js

@@ -0,0 +1,39 @@
+/**
+ * An empty, invisible element whose only job is to occupy a position in the DOM.
+ *
+ * At the top of the document `firstBlockNodeStyles` zeroes the top margin of whatever element
+ * follows a leading `.ProseMirror-widget`, and it does so with `!important` — which no inline style
+ * can outrank. This takes that hit so the shaped spacer after it, one position further along, keeps
+ * the margin it is there to supply.
+ *
+ * It contributes no height (no content, border or padding) and margins collapse through it, so it
+ * cannot affect layout beyond the selector it absorbs.
+ */
+export const createMarginAbsorber = ({
+  testId
+}) => {
+  // Block-level: an empty inline element takes the match just as well, but collapses to a
+  // zero-height line box, and the following margin then lands in the wrong place.
+  const absorber = document.createElement('div');
+  absorber.dataset.testid = testId;
+  absorber.setAttribute('aria-hidden', 'true');
+  absorber.contentEditable = 'false';
+  return absorber;
+};
+
+/**
+ * An absorber that occupies a DOM position without generating a box.
+ *
+ * Not interchangeable with `createMarginAbsorber`: a rule that selects the *rendered* sibling of a
+ * leading widget needs an element that generates a box, and this one does not.
+ */
+export const createBoxlessMarginAbsorber = ({
+  testId
+}) => {
+  const absorber = document.createElement('div');
+  absorber.dataset.testid = testId;
+  absorber.setAttribute('aria-hidden', 'true');
+  absorber.contentEditable = 'false';
+  absorber.style.display = 'contents';
+  return absorber;
+};

package/dist/es2019/pm-plugins/decorations/utils/createNodeShapedMarginSpacer.js

@@ -0,0 +1,69 @@
+/**
+ * Node types that can safely be reduced to an empty shell.
+ *
+ * A shell only replicates a margin if it collapses to nothing itself, which needs zero height and
+ * no vertical border or padding. Textblocks and lists qualify; nodes with intrinsic sizing (tables
+ * are `display: table`, media has a measured height) or a painted box (a zero-height panel is a
+ * visible stripe of background) do not, and are left alone.
+ */
+const isShapeableNode = node => node.isTextblock || ['bulletList', 'orderedList'].includes(node.type.name);
+
+/**
+ * An invisible element shaped like `node`, used to supply the top margin `node` no longer gets.
+ *
+ * A node at the start of its parent has its top margin reset, so a diff widget rendered above it
+ * sits flush against it. The reset cannot simply be taken off the node: the container variants skip
+ * widgets when counting — `nth-child(1 of :not(style, .ProseMirror-gapcursor, .ProseMirror-widget,
+ * span))` in layout columns, expands, sync blocks and table cells — so no amount of extra elements
+ * moves the match. That exclusion is what makes this work instead: the spacer is a
+ * `.ProseMirror-widget`, so it is never the counted first child and keeps its own margin, while the
+ * real node goes on taking the reset.
+ *
+ * The margin is not measured. Reading it off the real node is impossible — by then the reset has
+ * set it to `0`, and both `firstBlockNodeStyles` (`!important`) and block controls' `firstNodeDec`
+ * (an inline style) make it unrecoverable. Instead the spacer carries the node's own tag, classes
+ * and attributes, so the same rules that would have given the node its margin match the spacer
+ * (`.ProseMirror p`, `.ProseMirror h2`, the root-list rule, and so on).
+ *
+ * Returns `null` when the node is not safely shapeable or serialization fails.
+ */
+export const createNodeShapedMarginSpacer = ({
+  node,
+  serializer,
+  testId
+}) => {
+  var _node$type$createAndF;
+  if (!isShapeableNode(node)) {
+    return null;
+  }
+
+  // An empty node of the same type serializes to the same shell without walking real content.
+  const shellNode = (_node$type$createAndF = node.type.createAndFill(node.attrs)) !== null && _node$type$createAndF !== void 0 ? _node$type$createAndF : node;
+  const serialized = serializer.serializeNode(shellNode);
+  if (!(serialized instanceof HTMLElement)) {
+    return null;
+  }
+
+  // Keep the tag, classes and attributes the margin rules select on; drop anything that could
+  // occupy a line box.
+  serialized.replaceChildren();
+  serialized.dataset.testid = testId;
+  serialized.setAttribute('aria-hidden', 'true');
+  serialized.contentEditable = 'false';
+
+  // Zero height with no vertical border or padding keeps the spacer self-collapsing: its margins
+  // stay adjoining, so they collapse with the neighbours into a single margin equal to the largest
+  // rather than adding to them. That is what makes this safe in containers that never reset the
+  // first child — the spacer cannot double the gap there. Deliberately no `overflow: hidden`, which
+  // would open a block formatting context and stop that collapsing.
+  serialized.style.height = '0';
+  serialized.style.minHeight = '0';
+  serialized.style.paddingTop = '0';
+  serialized.style.paddingBottom = '0';
+  serialized.style.borderTopWidth = '0';
+  serialized.style.borderBottomWidth = '0';
+  // Only the top margin is being replicated. Left as-is, a larger bottom margin would win the
+  // self-collapse and overshoot the gap.
+  serialized.style.marginBottom = '0';
+  return serialized;
+};

package/dist/es2019/pm-plugins/decorations/utils/safeResolve.js

@@ -0,0 +1,18 @@
+/**
+ * Resolves a document position, or returns `null` if it cannot be resolved.
+ *
+ * `Node.resolve` throws a `RangeError` for a position outside the document. Diff decorations are
+ * built from change ranges computed against a document that may since have moved on, so a position
+ * arriving out of range is a normal outcome rather than a defect — but an exception escaping here
+ * takes down the whole decoration set, leaving the diff unrendered.
+ *
+ * Callers are expected to treat `null` as "cannot tell" and fall back to behaviour that does not
+ * need the resolved position.
+ */
+export const safeResolve = (doc, pos) => {
+  try {
+    return doc.resolve(pos);
+  } catch {
+    return null;
+  }
+};

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

@@ -49,6 +49,17 @@ function decorationSide(decoration) {
   return isDiffDecoration(decoration) && decoration.spec.side || 0;
 }
 
+/**
+ * Whose change a decoration is part of, or `''` on an unattributed diff — where every decoration
+ * reads as one contributor and the grouping below is unchanged.
+ *
+ * Contributors are kept apart so one stop never covers two of them, since only the tag on the
+ * change stepped to reveals (EDITOR-8932).
+ */
+function contributorOf(decoration) {
+  return isDiffDecoration(decoration) && decoration.spec.attributionKey || '';
+}
+
 /**
  * Collapses decorations that represent one continuous customer-facing edit.
  *
@@ -57,32 +68,46 @@ function decorationSide(decoration) {
  * deletion at the same location should be treated as one replacement. Zero-width decorations
  * (normally deleted-content widgets) can join a group, but cannot extend its range and therefore
  * cannot bridge two otherwise separate edits.
+ *
+ * One group per contributor within a run of touching ranges — see `contributorOf`.
  */
 function groupTouchingDecorations(decorations, isInlineDecoration) {
   if (decorations.length < 2) {
     return decorations;
   }
   const groups = [];
-  let currentGroup = [];
-  let currentGroupFrom = 0;
-  let currentGroupTo = 0;
+  // The groups a following decoration can still join — one per contributor, dropped at every gap.
+  let openGroups = [];
+  let clusterTo = 0;
   const sortedDecorations = [...decorations].sort((a, b) => a.from === b.from ? a.to - b.to : a.from - b.from);
   sortedDecorations.forEach(decoration => {
-    if (currentGroup.length === 0 || decoration.from > currentGroupTo) {
-      currentGroup = [decoration];
-      currentGroupFrom = decoration.from;
-      currentGroupTo = decoration.to;
-      groups.push({
-        decorations: currentGroup,
-        from: currentGroupFrom,
-        to: currentGroupTo
-      });
-      return;
+    var _openGroups$find;
+    // A gap ends the run: nothing before it can be joined.
+    if (decoration.from > clusterTo) {
+      openGroups = [];
     }
-    currentGroup.push(decoration);
-    // A zero-width decoration must not extend the group and bridge a gap.
-    currentGroupTo = Math.max(currentGroupTo, decoration.to);
-    groups[groups.length - 1].to = currentGroupTo;
+    const contributor = contributorOf(decoration);
+    // An unattributed decoration names nobody to keep apart, so it joins whatever is open — a
+    // decision item's own highlight must not split the stop from the tag on its list.
+    const openGroup = (_openGroups$find = openGroups.find(group => group.contributor === contributor)) !== null && _openGroups$find !== void 0 ? _openGroups$find : contributor === '' ? openGroups[0] : openGroups.find(group => group.contributor === '');
+    if (openGroup === undefined) {
+      const group = {
+        contributor,
+        decorations: [decoration],
+        from: decoration.from,
+        to: decoration.to
+      };
+      groups.push(group);
+      openGroups = [...openGroups, group];
+    } else {
+      // The first contributor to join claims the group, so the next one still starts its own.
+      openGroup.contributor = openGroup.contributor || contributor;
+      openGroup.decorations.push(decoration);
+      openGroup.to = Math.max(openGroup.to, decoration.to);
+    }
+
+    // A zero-width decoration must not extend the run and bridge a gap.
+    clusterTo = Math.max(clusterTo, decoration.to);
   });
   return groups.map(({
     decorations: group,
@@ -127,8 +152,8 @@ function groupTouchingDecorations(decorations, isInlineDecoration) {
  * 4. When `doc` is passed: excludes diff-inline decorations whose range has no inline content
  *    (invalid positions, or block-only slices with no text/atoms — e.g. empty blocks)
  * 5. When `confluence_ncs_step_diffing_version_history` is enabled, groups overlapping or
- *    directly touching ranges across decoration types into one result, using the union of all
- *    grouped ranges
+ *    directly touching ranges across decoration types into one result per contributor, using the
+ *    union of all grouped ranges
  *    (zero-width widgets can join a group without extending it). Under
  *    `platform_editor_ai_show_diff_patch_1`, a group that starts with content painting above
  * 	  the content that replaced it — reports that widget as its `scrollTarget` spec,

package/dist/es2019/pm-plugins/utils/baseNodeName.js

@@ -0,0 +1,18 @@
+import { fg } from '@atlaskit/platform-feature-flags/fg';
+
+/**
+ * A node type's base name, with a schema variant's suffix stripped: `panel`, `panel_c1` and
+ * `panel_c1_root_only` all resolve to `panel`.
+ *
+ * Package-local rather than `getBaseNodeTypeName` from editor-common, which enumerates the variants
+ * it happens to know (`panel_c1` alone) and is shared with features outside this one. Derived
+ * instead of listed, so a variant added later needs no change here: the schema generator names a
+ * variant `<type>_<variant>`, and every other node name in the ADF schema is camelCase, so the
+ * first `_` is the boundary.
+ *
+ * Gated, so the diff behaves exactly as before for anyone outside the rollout.
+ *
+ * For taggability only — this gate is weaker than the ones attribution needs, so resolving a variant
+ * in the styling decisions would move the legacy diff for readers who see no tags.
+ */
+export const resolveBaseNodeName = name => fg('confluence_ncs_step_diffing_version_history') ? name.split('_')[0] : name;

package/dist/es2019/pm-plugins/utils/taggableBlockNodes.js

@@ -0,0 +1,28 @@
+import { resolveBaseNodeName } from './baseNodeName';
+
+/**
+ * Block nodes that host a contributor tag of their own — those whose whole box reads as one change.
+ * Everything that draws a box whatever it holds, plus the two lists that are inserted whole: without
+ * them the tag fell through to the text inside the first item (EDITOR-8932). Bullet and ordered lists
+ * are left out, since their items accrue one at a time. Tables and list items decorate per cell and
+ * per item, with no one-tag-per-block design yet. `blockCard` covers the datasource variant, which is
+ * the same node type.
+ *
+ * Base names only — match with the predicates below, never against `type.name` directly.
+ */
+const TAGGABLE_BLOCK_NODES = new Set(['blockCard', 'blockquote', 'bodiedExtension', 'codeBlock', 'decisionList', 'embedCard', 'expand', 'extension', 'media', 'multiBodiedExtension', 'panel', 'rule', 'taskList']);
+
+/**
+ * Whether this node hosts a contributor tag of its own. Navigation grouping does not consult this:
+ * a run of these one contributor inserted is a single stop, tagged on the leading block.
+ *
+ * Resolved through `resolveBaseNodeName` so a schema variant counts as the type it is a variant of:
+ * `panel_c1` is the panel the table-in-panel schema inserts, and matching on `type.name` left it
+ * untagged (EDITOR-8932).
+ *
+ * By name, because the decoration spec carries `nodeName` rather than the type it came from.
+ */
+export const isTaggableBlockNodeName = name => name !== undefined && TAGGABLE_BLOCK_NODES.has(resolveBaseNodeName(name));
+
+/** As above, from the node type itself. */
+export const isTaggableBlockNode = nodeType => isTaggableBlockNodeName(nodeType.name);

package/dist/es2019/ui/ContributorTag/contributorTagController.js

@@ -290,11 +290,11 @@ export class ContributorTagController {
 
     // Hand-rolled avatar stack: `@atlaskit/avatar-group` cannot render below 24px and the tag uses
     // 16px avatars.
-    const stack = model.connectedContributor ? [...(user ? [{
-      contributor: user,
-      stackIndex: 1
-    }] : []), ...(agent ? [{
+    const stack = model.connectedContributor ? [...(agent ? [{
       contributor: agent,
+      stackIndex: 1
+    }] : []), ...(user ? [{
+      contributor: user,
       stackIndex: 0
     }] : [])] : [{
       contributor: model.contributor