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

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

@@ -1,5 +1,5 @@
-import _toArray from "@babel/runtime/helpers/toArray";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _toArray from "@babel/runtime/helpers/toArray";
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
 var _excluded = ["connectedToKey"];
@@ -51,6 +51,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
@@ -71,6 +79,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
@@ -139,6 +160,10 @@ export var extractContributorTags = function extractContributorTags(decorations,
   });
   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);
@@ -196,58 +221,113 @@ export var extractContributorTags = function extractContributorTags(decorations,
     if (_ret === 0) continue;
   }
 
+  // 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')) {
+    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(_toConsumableArray((_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 = _toConsumableArray(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(_toConsumableArray((_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(_toConsumableArray((_byStopAndContributor = byStopAndContributor.get(_key)) !== null && _byStopAndContributor !== void 0 ? _byStopAndContributor : []), [_target2]));
       }
-      var _iterator4 = _createForOfIteratorHelper(byContributor.values()),
-        _step4;
-      try {
-        var _loop2 = function _loop2() {
-          var _step4$value = _toArray(_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 = _toConsumableArray(members).sort(byLeadingPosition),
+          _sort2 = _toArray(_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/esm/pm-plugins/decorations/revealStyles.js

@@ -1,4 +1,5 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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';
@@ -108,6 +109,7 @@ export var resolveRevealStyle = function resolveRevealStyle(_ref4) {
     return undefined;
   }
   var colors = getColorScheme(colorScheme);
+  var brand = isInserted && Object.prototype.hasOwnProperty.call(agentBrandColorSchemes, colors.insertColor) ? agentBrandColorSchemes[colors.insertColor] : undefined;
   var _resolveRevealColors = resolveRevealColors(colors, {
       hideAddedDiffsUnderline: hideAddedDiffsUnderline,
       isActive: isActive,
@@ -117,7 +119,9 @@ export var resolveRevealStyle = function resolveRevealStyle(_ref4) {
     border = _resolveRevealColors.border;
   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: background,
       border: border
     })

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

@@ -54,6 +54,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.
  *
@@ -62,34 +73,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 = _toConsumableArray(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(_toConsumableArray(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;
@@ -136,8 +165,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/esm/pm-plugins/utils/baseNodeName.js

@@ -0,0 +1,20 @@
+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 var resolveBaseNodeName = function resolveBaseNodeName(name) {
+  return fg('confluence_ncs_step_diffing_version_history') ? name.split('_')[0] : name;
+};

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

@@ -0,0 +1,32 @@
+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.
+ */
+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.
+ */
+export var isTaggableBlockNodeName = function isTaggableBlockNodeName(name) {
+  return name !== undefined && TAGGABLE_BLOCK_NODES.has(resolveBaseNodeName(name));
+};
+
+/** As above, from the node type itself. */
+export var isTaggableBlockNode = function isTaggableBlockNode(nodeType) {
+  return isTaggableBlockNodeName(nodeType.name);
+};

package/dist/types/pm-plugins/calculateDiff/simplifyChangesWithAttribution.d.ts

@@ -1,5 +1,17 @@
 import { type Change } from 'prosemirror-changeset';
 import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+type Range = {
+    from: number;
+    to: number;
+};
+/**
+ * A change, plus the block nodes it owns when it is one piece of a split — a piece's own range no
+ * longer covers the container it opened. Absent on an unsplit change, which decorates the blocks
+ * inside its own range as before.
+ */
+export type AttributedChange = Change & {
+    blockNodeRangesB?: Range[];
+};
 /**
  * Collapses changes whose new-document ranges strictly overlap. Attribution runs are simplified
  * independently, so runs either side of an unattributed step can come back covering the same
@@ -8,10 +20,17 @@ import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
  * Merging keeps every span from both sides, so the latest-writer rule still decides whose tag is
  * shown. Ranges that merely touch are left alone, so an unattributed edit next to an attributed one
  * is not credited to it.
+ *
+ * Contributors are separated first, by `splitMixedIdentityChanges` and `splitContainedChanges`.
+ * Both leave ranges that only touch, so they survive the collapse.
+ *
+ * Carries no gate of its own: the only caller reaches it through the attributed changeset, which
+ * already requires `confluence_ncs_step_diffing_version_history`.
  */
-export declare const collapseOverlappingChanges: (changes: Change[]) => Change[];
+export declare const collapseOverlappingChanges: (changes: Change[], doc?: PMNode) => AttributedChange[];
 /**
  * Simplifies and optimizes consecutive changes without crossing an attribution boundary.
  * A change which already contains more than one identity is deliberately kept isolated.
  */
 export declare const simplifyChangesWithAttribution: (changes: readonly Change[], doc: PMNode) => Change[];
+export {};

package/dist/types/pm-plugins/decorations/colorSchemes/factory.d.ts

@@ -1,4 +1,4 @@
-import type { AdsAccentColor, DiffColorScheme } from './types';
+import type { AccentColor, DiffColorScheme } from './types';
 /**
  * Hover highlight for deleted text under an 'onEmphasis' scheme. Inline styles cannot express
  * `:hover`, so the resting style resolves its background from this property and
@@ -12,20 +12,13 @@ export declare const DELETED_HIGHLIGHT_BG_VAR = "--show-diff-deleted-highlight-b
  * 'underline' scheme can darken the border without darkening the tint behind it.
  */
 export declare const DELETED_HIGHLIGHT_BORDER_VAR = "--show-diff-deleted-highlight-border";
-/**
- * Presentation tokens for a contributor tag in one diff colour.
- *
- * A `bolder` fill rather than the `subtlest` tint the highlight uses: the tag is a label on the
- * change, and at tag size a tint reads as a second, weaker highlight sitting above the real one.
- * `inverse` is the only text tone that reads on a bolder fill, and it needs no per-colour map —
- * which is also why the tag carries no border: the fill alone bounds it.
- */
-export declare function getAccentTokens(color: AdsAccentColor): {
+/** Contributor tags use a bold fill with a contrasting foreground, including branded schemes. */
+export declare function getAccentTokens(color: AccentColor): {
     background: string;
     text: string;
 };
 /** Border token for a contributor accent, used by the diff indicator. */
-export declare function getAccentBorderColor(color: AdsAccentColor): string;
+export declare function getAccentBorderColor(color: AccentColor): string;
 /** Inline inserted content — default state. */
 export declare function buildInsertStyle(colors: DiffColorScheme): string;
 /** Inline insert style for content within a block node (no background, underline only). */

package/dist/types/pm-plugins/decorations/colorSchemes/types.d.ts

@@ -1,11 +1,12 @@
+import type { AgentBrandColorScheme } from '@atlaskit/agent-color/agent-presence-color-types';
 /** Schemes consumers may explicitly request through the show-diff API. */
 export type PublicColorScheme = 'standard' | 'traditional';
 /** Attribution-only participant slots selected by the plugin, never by consumers. */
 export declare const PARTICIPANT_COLOR_SCHEMES: readonly ['red', 'blue', 'green', 'yellow', 'purple', 'magenta', 'teal', 'orange', 'lime', 'gray'];
 /** ADS accent hues used by the public and participant colour schemes. */
 export type AdsAccentColor = (typeof PARTICIPANT_COLOR_SCHEMES)[number];
-/** A public scheme or an attribution participant slot resolved internally for one change. */
-export type ColorScheme = PublicColorScheme | AdsAccentColor;
+export type AccentColor = AdsAccentColor | AgentBrandColorScheme;
+export type ColorScheme = PublicColorScheme | AccentColor;
 /**
  * A show-diff colour scheme. Colour fields are ADS hues that `factory.ts` expands into token paths;
  * the rest encode structural differences no colour can express. Ring widths, padding, radius and
@@ -15,15 +16,15 @@ export type DiffColorScheme = {
     /** Stacking order of the square added-cell overlay. The rounded variant is always 2. */
     addedCellOverlayZIndex: 1 | 2;
     /** Deleted inline content, active/focused state. */
-    deleteActiveColor: AdsAccentColor;
+    deleteActiveColor: AccentColor;
     /** Deleted inline content. */
-    deleteColor: AdsAccentColor;
+    deleteColor: AccentColor;
     /** Active deleted-block ring: pale `background.accent.*.subtler.pressed` vs saturated `border.accent.*`. */
     deletedBlockOutlineActiveEmphasis: 'background' | 'border';
     /** Deleted cell outline: `color.border.disabled` hairline vs opaque accent border. */
     deletedCellBorderProminence: 'subtle' | 'accent';
     /** Deleted cell overlays. Gray in both current schemes. */
-    deletedCellColor: AdsAccentColor;
+    deletedCellColor: AccentColor;
     /** Opacity of the deleted cell overlay background. Counterpart to `insertedCellOpacity`. */
     deletedCellOpacity: number;
     /**
@@ -62,11 +63,11 @@ export type DiffColorScheme = {
     /** Deleted row de-emphasis: tint the line-through, or tint the row text. Both read `deleteColor`. */
     deletedRowTreatment: 'strikeColor' | 'textTint';
     /** Optional text and strikethrough hue, independent of deletion borders. */
-    deleteTextColor?: AdsAccentColor;
+    deleteTextColor?: AccentColor;
     /** Inserted content, active/focused state. */
-    insertActiveColor: AdsAccentColor;
+    insertActiveColor: AccentColor;
     /** Inserted content, default state. */
-    insertColor: AdsAccentColor;
+    insertColor: AccentColor;
     /** Opacity of the inserted cell overlay background. */
     insertedCellOpacity: number;
     /** Bottom border tone for inserted text highlights. Defaults to accent. */

package/dist/types/pm-plugins/getScrollableDecorations.d.ts

@@ -18,8 +18,8 @@ export declare function isInlineDiffDecorationRenderableInDoc(doc: PMNode, from:
  * 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/types/pm-plugins/utils/baseNodeName.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 declare const resolveBaseNodeName: (name: string) => string;

package/dist/types/pm-plugins/utils/taggableBlockNodes.d.ts

@@ -0,0 +1,14 @@
+import type { NodeType } from '@atlaskit/editor-prosemirror/model';
+/**
+ * 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 declare const isTaggableBlockNodeName: (name: string | undefined) => boolean;
+/** As above, from the node type itself. */
+export declare const isTaggableBlockNode: (nodeType: NodeType) => boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-show-diff",
-	"version": "16.1.1",
+	"version": "16.2.0",
 	"description": "ShowDiff plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -26,6 +26,7 @@
 	"atlaskit:src": "src/index.ts",
 	"dependencies": {
 		"@atlaskit/adf-schema": "^57.5.0",
+		"@atlaskit/agent-color": "^0.2.0",
 		"@atlaskit/avatar": "^28.0.0",
 		"@atlaskit/custom-steps": "^1.1.0",
 		"@atlaskit/editor-plugin-accessibility-utils": "^18.0.0",
@@ -39,7 +40,7 @@
 		"@atlaskit/platform-feature-flags": "^2.2.0",
 		"@atlaskit/primitives": "^22.5.0",
 		"@atlaskit/tmp-editor-statsig": "^199.0.0",
-		"@atlaskit/tokens": "^18.0.0",
+		"@atlaskit/tokens": "^18.1.0",
 		"@babel/runtime": "^7.0.0",
 		"@compiled/react": "^1.0.2",
 		"bind-event-listener": "^3.0.0",
@@ -63,14 +64,14 @@
 		"@atlassian/confluence-presets": "workspace:^",
 		"@atlassian/content-reconciliation": "^0.1.3506",
 		"@atlassian/editor-ai-injected-editors": "^32.0.0",
-		"@atlassian/editor-plugin-ai": "^72.3.0",
+		"@atlassian/editor-plugin-ai": "^72.4.0",
 		"@atlassian/structured-docs-types": "workspace:^",
 		"react": "^19.2.0",
 		"react-dom": "^19.2.0",
 		"react-intl": "^7.0.0"
 	},
 	"peerDependencies": {
-		"@atlaskit/editor-common": "^122.11.0",
+		"@atlaskit/editor-common": "^122.12.0",
 		"react": "^18.2.0 || ^19.2.0",
 		"react-dom": "^18.2.0 || ^19.2.0",
 		"react-intl": "^5.25.1 || ^6.0.0 || ^7.0.0"