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

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

@@ -5,8 +5,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.extractContributorTags = void 0;
-var _toArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toArray"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _toArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toArray"));
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
 var _fg = require("@atlaskit/platform-feature-flags/fg");
@@ -57,6 +57,14 @@ var isSameBlockChange = function isSameBlockChange(inner, block) {
   return 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).
+ */
+var containsBlock = function containsBlock(outer, inner) {
+  return 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
@@ -77,6 +85,19 @@ var containedBy = function containedBy(targets, _ref2) {
   }).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).
+ */
+var owningStop = function owningStop(target, stops) {
+  return stops.reduce(function (narrowest, stop) {
+    return 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
@@ -145,6 +166,10 @@ var extractContributorTags = exports.extractContributorTags = function extractCo
   });
   var linkedDiffIds = new Map();
   var folded = new Set();
+
+  /**
+   * A folded target keeps no tag of its own — it becomes a hover target of the host instead.
+   */
   var fold = function fold(host, target) {
     var _linkedDiffIds$get, _linkedDiffIds$get2;
     folded.add(target);
@@ -202,58 +227,113 @@ var extractContributorTags = exports.extractContributorTags = function extractCo
     if (_ret === 0) continue;
   }
 
+  // A nested block folds into the outermost one of the same contributor, so nesting adds no tags.
+  if ((0, _fg.fg)('confluence_ncs_step_diffing_version_history')) {
+    var blocksByContributor = new Map();
+    var _iterator2 = _createForOfIteratorHelper(blockTargets),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _target$decoration$sp, _blocksByContributor$;
+        var target = _step2.value;
+        var key = (_target$decoration$sp = target.decoration.spec.attributionKey) !== null && _target$decoration$sp !== void 0 ? _target$decoration$sp : '';
+        blocksByContributor.set(key, [].concat((0, _toConsumableArray2.default)((_blocksByContributor$ = blocksByContributor.get(key)) !== null && _blocksByContributor$ !== void 0 ? _blocksByContributor$ : []), [target]));
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    var _iterator3 = _createForOfIteratorHelper(blocksByContributor.values()),
+      _step3;
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var contributorBlocks = _step3.value;
+        // 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.
+        var nested = (0, _toConsumableArray2.default)(contributorBlocks).sort(function (left, right) {
+          return left.decoration.from - right.decoration.from || right.decoration.to - left.decoration.to;
+        });
+        var open = [];
+        var _iterator4 = _createForOfIteratorHelper(nested),
+          _step4;
+        try {
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var _target = _step4.value;
+            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);
+          }
+        } catch (err) {
+          _iterator4.e(err);
+        } finally {
+          _iterator4.f();
+        }
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+  }
+
   // 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.
-  var _iterator2 = _createForOfIteratorHelper(stops !== null && stops !== void 0 ? stops : []),
-    _step2;
-  try {
-    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-      var stop = _step2.value;
-      var byContributor = new Map();
-      var _iterator3 = _createForOfIteratorHelper(containedBy(targets.filter(function (target) {
-          return !folded.has(target);
-        }), stop)),
-        _step3;
-      try {
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          var _target$decoration$sp, _byContributor$get;
-          var target = _step3.value;
-          var key = (_target$decoration$sp = target.decoration.spec.attributionKey) !== null && _target$decoration$sp !== void 0 ? _target$decoration$sp : '';
-          byContributor.set(key, [].concat((0, _toConsumableArray2.default)((_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) {
+    var byStopAndContributor = new Map();
+    var _iterator5 = _createForOfIteratorHelper(targets.filter(function (target) {
+        return !folded.has(target);
+      })),
+      _step5;
+    try {
+      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        var _target2$decoration$s, _byStopAndContributor;
+        var _target2 = _step5.value;
+        var stop = owningStop(_target2, stops);
+        if (stop === undefined) {
+          continue;
         }
-      } catch (err) {
-        _iterator3.e(err);
-      } finally {
-        _iterator3.f();
+        var _key = "".concat(stop.from, "-").concat(stop.to, "|").concat((_target2$decoration$s = _target2.decoration.spec.attributionKey) !== null && _target2$decoration$s !== void 0 ? _target2$decoration$s : '');
+        byStopAndContributor.set(_key, [].concat((0, _toConsumableArray2.default)((_byStopAndContributor = byStopAndContributor.get(_key)) !== null && _byStopAndContributor !== void 0 ? _byStopAndContributor : []), [_target2]));
       }
-      var _iterator4 = _createForOfIteratorHelper(byContributor.values()),
-        _step4;
-      try {
-        var _loop2 = function _loop2() {
-          var _step4$value = (0, _toArray2.default)(_step4.value),
-            leader = _step4$value[0],
-            trailing = _arrayLikeToArray(_step4$value).slice(1);
-          trailing.forEach(function (target) {
-            return fold(leader, target);
-          });
-        };
-        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-          _loop2();
-        }
-      } catch (err) {
-        _iterator4.e(err);
-      } finally {
-        _iterator4.f();
+    } catch (err) {
+      _iterator5.e(err);
+    } finally {
+      _iterator5.f();
+    }
+    var _iterator6 = _createForOfIteratorHelper(byStopAndContributor.values()),
+      _step6;
+    try {
+      var _loop2 = function _loop2() {
+        var members = _step6.value;
+        var _sort = (0, _toConsumableArray2.default)(members).sort(byLeadingPosition),
+          _sort2 = (0, _toArray2.default)(_sort),
+          leader = _sort2[0],
+          trailing = _arrayLikeToArray(_sort2).slice(1);
+        trailing.forEach(function (target) {
+          return fold(leader, target);
+        });
+      };
+      for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+        _loop2();
       }
+    } catch (err) {
+      _iterator6.e(err);
+    } finally {
+      _iterator6.f();
     }
-  } catch (err) {
-    _iterator2.e(err);
-  } finally {
-    _iterator2.f();
   }
   var surviving = targets.filter(function (target) {
     return !folded.has(target);

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

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.resolveRevealStyle = exports.buildWipeableBackground = exports.applyRevealToElement = exports.REVEAL_BORDER_VAR = exports.REVEAL_BG_VAR = exports.REVEAL_ATTR = void 0;
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _agentBrandColorSchemes = require("@atlaskit/agent-color/agent-brand-color-schemes");
 var _lazyNodeView = require("@atlaskit/editor-common/lazy-node-view");
 var _isExperimentEnabled = require("@atlaskit/platform-feature-experiments/is-experiment-enabled");
 var _factory = require("./colorSchemes/factory");
@@ -115,6 +116,7 @@ var resolveRevealStyle = exports.resolveRevealStyle = function resolveRevealStyl
     return undefined;
   }
   var colors = getColorScheme(colorScheme);
+  var brand = isInserted && Object.prototype.hasOwnProperty.call(_agentBrandColorSchemes.agentBrandColorSchemes, colors.insertColor) ? _agentBrandColorSchemes.agentBrandColorSchemes[colors.insertColor] : undefined;
   var _resolveRevealColors = resolveRevealColors(colors, {
       hideAddedDiffsUnderline: hideAddedDiffsUnderline,
       isActive: isActive,
@@ -124,7 +126,9 @@ var resolveRevealStyle = exports.resolveRevealStyle = function resolveRevealStyl
     border = _resolveRevealColors.border;
   return {
     role: isInserted ? 'added' : 'deleted',
-    style: (isInserted || !includeDeletedTextStyle ? '' : deletedTextOnlyStyle(colors, isActive)) + revealBaseStyle + buildWipeableBackground(background) + buildRevealVariables({
+    style: (brand ? (0, _lazyNodeView.convertToInlineCss)({
+      color: brand.text
+    }) : '') + (isInserted || !includeDeletedTextStyle ? '' : deletedTextOnlyStyle(colors, isActive)) + revealBaseStyle + buildWipeableBackground(background) + buildRevealVariables({
       background: background,
       border: border
     })

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

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.absorbFirstChildMarginReset = void 0;
+var _createMarginAbsorber = require("./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.
+ */
+var absorbFirstChildMarginReset = exports.absorbFirstChildMarginReset = function absorbFirstChildMarginReset(_ref) {
+  var dom = _ref.dom,
+    testId = _ref.testId;
+  dom.prepend((0, _createMarginAbsorber.createBoxlessMarginAbsorber)({
+    testId: testId
+  }));
+};

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

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMarginAbsorber = exports.createBoxlessMarginAbsorber = void 0;
+/**
+ * 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.
+ */
+var createMarginAbsorber = exports.createMarginAbsorber = function createMarginAbsorber(_ref) {
+  var testId = _ref.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.
+  var 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.
+ */
+var createBoxlessMarginAbsorber = exports.createBoxlessMarginAbsorber = function createBoxlessMarginAbsorber(_ref2) {
+  var testId = _ref2.testId;
+  var absorber = document.createElement('div');
+  absorber.dataset.testid = testId;
+  absorber.setAttribute('aria-hidden', 'true');
+  absorber.contentEditable = 'false';
+  absorber.style.display = 'contents';
+  return absorber;
+};

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

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createNodeShapedMarginSpacer = void 0;
+/**
+ * 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.
+ */
+var isShapeableNode = function isShapeableNode(node) {
+  return 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.
+ */
+var createNodeShapedMarginSpacer = exports.createNodeShapedMarginSpacer = function createNodeShapedMarginSpacer(_ref) {
+  var _node$type$createAndF;
+  var node = _ref.node,
+    serializer = _ref.serializer,
+    testId = _ref.testId;
+  if (!isShapeableNode(node)) {
+    return null;
+  }
+
+  // An empty node of the same type serializes to the same shell without walking real content.
+  var shellNode = (_node$type$createAndF = node.type.createAndFill(node.attrs)) !== null && _node$type$createAndF !== void 0 ? _node$type$createAndF : node;
+  var 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/cjs/pm-plugins/decorations/utils/safeResolve.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.safeResolve = void 0;
+/**
+ * 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.
+ */
+var safeResolve = exports.safeResolve = function safeResolve(doc, pos) {
+  try {
+    return doc.resolve(pos);
+  } catch (_unused) {
+    return null;
+  }
+};

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

@@ -61,6 +61,17 @@ function decorationSide(decoration) {
   return (0, _decorationKeys.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 (0, _decorationKeys.isDiffDecoration)(decoration) && decoration.spec.attributionKey || '';
+}
+
 /**
  * Collapses decorations that represent one continuous customer-facing edit.
  *
@@ -69,34 +80,52 @@ 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;
   }
   var groups = [];
-  var currentGroup = [];
-  var currentGroupFrom = 0;
-  var currentGroupTo = 0;
+  // The groups a following decoration can still join — one per contributor, dropped at every gap.
+  var openGroups = [];
+  var clusterTo = 0;
   var sortedDecorations = (0, _toConsumableArray2.default)(decorations).sort(function (a, b) {
     return a.from === b.from ? a.to - b.to : a.from - b.from;
   });
   sortedDecorations.forEach(function (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;
+    var 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.
+    var openGroup = (_openGroups$find = openGroups.find(function (group) {
+      return group.contributor === contributor;
+    })) !== null && _openGroups$find !== void 0 ? _openGroups$find : contributor === '' ? openGroups[0] : openGroups.find(function (group) {
+      return group.contributor === '';
+    });
+    if (openGroup === undefined) {
+      var group = {
+        contributor: contributor,
+        decorations: [decoration],
+        from: decoration.from,
+        to: decoration.to
+      };
+      groups.push(group);
+      openGroups = [].concat((0, _toConsumableArray2.default)(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(function (_ref) {
     var _ref2, _group$find;
@@ -143,8 +172,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/cjs/pm-plugins/utils/baseNodeName.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveBaseNodeName = void 0;
+var _fg = require("@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.
+ */
+var resolveBaseNodeName = exports.resolveBaseNodeName = function resolveBaseNodeName(name) {
+  return (0, _fg.fg)('confluence_ncs_step_diffing_version_history') ? name.split('_')[0] : name;
+};

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

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isTaggableBlockNodeName = exports.isTaggableBlockNode = void 0;
+var _baseNodeName = require("./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.
+ */
+var 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.
+ */
+var isTaggableBlockNodeName = exports.isTaggableBlockNodeName = function isTaggableBlockNodeName(name) {
+  return name !== undefined && TAGGABLE_BLOCK_NODES.has((0, _baseNodeName.resolveBaseNodeName)(name));
+};
+
+/** As above, from the node type itself. */
+var isTaggableBlockNode = exports.isTaggableBlockNode = function isTaggableBlockNode(nodeType) {
+  return isTaggableBlockNodeName(nodeType.name);
+};

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

@@ -332,11 +332,11 @@ var ContributorTagController = exports.ContributorTagController = /*#__PURE__*/f
 
       // Hand-rolled avatar stack: `@atlaskit/avatar-group` cannot render below 24px and the tag uses
       // 16px avatars.
-      var stack = model.connectedContributor ? [].concat((0, _toConsumableArray2.default)(user ? [{
-        contributor: user,
-        stackIndex: 1
-      }] : []), (0, _toConsumableArray2.default)(agent ? [{
+      var stack = model.connectedContributor ? [].concat((0, _toConsumableArray2.default)(agent ? [{
         contributor: agent,
+        stackIndex: 1
+      }] : []), (0, _toConsumableArray2.default)(user ? [{
+        contributor: user,
         stackIndex: 0
       }] : [])) : [{
         contributor: model.contributor