@atlaskit/editor-plugin-show-diff 14.2.10 → 14.2.11

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @atlaskit/editor-plugin-show-diff
 
+## 14.2.11
+
+### Patch Changes
+
+- [`15abc159d8096`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/15abc159d8096) -
+  Add mark (formatting) support to the non-smart diff types behind
+  `platform_editor_diff_inline_mark_changes`. A mark-only agent edit arrives as a `ReplaceStep`,
+  which the default `prosemirror-changeset` token encoder tokenises identically on both sides, so
+  bold/italic/code/link changes were silently invisible in the inline diff. A mark-aware token
+  encoder now folds marks into the character token, and mark-only changes render as an added-side
+  highlight without duplicating the unchanged text. No behaviour change with the gate off.
+- Updated dependencies
+
 ## 14.2.10
 
 ### Patch Changes

package/dist/cjs/pm-plugins/calculateDiff/attrAwareTokenEncoder.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.attrAwareTokenEncoder = void 0;
 var _nodeTypeUtils = require("@atlaskit/editor-common/utils/node-type-utils");
 var _diffableAttrs = require("../decorations/utils/diffableAttrs");
+var _encodeCharacterWithMarks = require("./encodeCharacterWithMarks");
 /**
  * Attribute-aware token encoder for `prosemirror-changeset`. The default encoder
  * reduces a node to `node.type.name`, so an attribute-only change (e.g. a table
@@ -25,33 +26,12 @@ var encodeNodeWithAttrs = function encodeNodeWithAttrs(node, attrNames) {
   return "".concat(node.type.name, "|").concat(parts.join('|'));
 };
 
-// Fold a character's marks (type + attrs) into its token so a formatting-only change
-// (bold/italic/link/colour, or a link whose `href` changes) registers as a real diff.
-// The default encoder returns just the char code, so marked and unmarked text tokenise
-// identically. Marks and their attrs are sorted so the token is order-independent.
-var encodeCharacterWithMarks = function encodeCharacterWithMarks(char, marks) {
-  if (marks.length === 0) {
-    // Fast path: unmarked text keeps the numeric char code (unchanged behaviour).
-    return char;
-  }
-  var markKey = marks.map(function (mark) {
-    var _mark$attrs;
-    var attrs = (_mark$attrs = mark.attrs) !== null && _mark$attrs !== void 0 ? _mark$attrs : {};
-    var attrParts = Object.keys(attrs).sort().map(function (key) {
-      var _attrs$key;
-      return "".concat(key, "=").concat(JSON.stringify((_attrs$key = attrs[key]) !== null && _attrs$key !== void 0 ? _attrs$key : null));
-    });
-    return attrParts.length > 0 ? "".concat(mark.type.name, "(").concat(attrParts.join(','), ")") : mark.type.name;
-  }).sort().join('&');
-  return "".concat(char, "\0").concat(markKey);
-};
-
 // Like the library default, but node types with a `diffableAttrs` rule fold their
 // attrs into the open token, and text characters fold in their marks. Node-end is
 // unchanged, hence `string | number`.
 var attrAwareTokenEncoder = exports.attrAwareTokenEncoder = {
   encodeCharacter: function encodeCharacter(char, marks) {
-    return encodeCharacterWithMarks(char, marks);
+    return (0, _encodeCharacterWithMarks.encodeCharacterWithMarks)(char, marks);
   },
   encodeNodeStart: function encodeNodeStart(node) {
     var _node$attrs2;

package/dist/cjs/pm-plugins/calculateDiff/calculateDiffDecorations.js

@@ -27,10 +27,11 @@ var _decorationKeys = require("../decorations/decorationKeys");
 var _getAttrChangeRanges = require("../decorations/utils/getAttrChangeRanges");
 var _getMarkChangeRanges = require("../decorations/utils/getMarkChangeRanges");
 var _isExtendedEnabled = require("../isExtendedEnabled");
-var _attrAwareTokenEncoder = require("./attrAwareTokenEncoder");
 var _diffBySteps = require("./diffBySteps");
 var _groupChangesByBlock = require("./groupChangesByBlock");
+var _isMarkOnlyChange = require("./isMarkOnlyChange");
 var _optimizeChanges = require("./optimizeChanges");
+var _selectTokenEncoder2 = require("./selectTokenEncoder");
 var _simplifyChangesWithAttribution = require("./simplifyChangesWithAttribution");
 var _simplifySteps = require("./simplifySteps");
 var _classifySmartChanges = require("./smart/classifySmartChanges");
@@ -389,10 +390,10 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref7
       };
     }
   }
-  // The attribute-aware encoder is only needed by the smart classifier and is
-  // gated with it; other diff types keep the library default so their output is
-  // unchanged.
-  var tokenEncoder = diffType === 'smart' && (0, _fg.fg)('platform_editor_ai_smart_diff') ? _attrAwareTokenEncoder.attrAwareTokenEncoder : undefined;
+  // The attribute-aware encoder is only needed by the smart classifier and is gated with it.
+  var _selectTokenEncoder = (0, _selectTokenEncoder2.selectTokenEncoder)(diffType === 'smart' && (0, _fg.fg)('platform_editor_ai_smart_diff')),
+    tokenEncoder = _selectTokenEncoder.tokenEncoder,
+    shouldHideMarkOnlyDeletions = _selectTokenEncoder.shouldHideMarkOnlyDeletions;
   var changes;
   var attributedChanges = [];
   var attributionColors;
@@ -447,6 +448,16 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref7
     var changeColorScheme = attributionColors ? (0, _attributions.getColorSchemeForChange)(change, attributedChanges, attributionColors, colorScheme) : colorScheme;
     var isActive = isRangeActive(activeIndexPos, change.fromB, change.toB);
 
+    // The deleted side of a mark-only change is a byte-identical copy of the new text, so it is
+    // suppressed in the clean view. `hideDeletedDiffs` is load-bearing: when false the reviewer
+    // asked to compare against the original, and the deleted side is the only place the
+    // previous formatting is visible.
+    var isMarkOnly = shouldHideMarkOnlyDeletions && hideDeletedDiffs && change.deleted.length > 0 && (0, _isMarkOnlyChange.isMarkOnlyChange)({
+      change: change,
+      originalDoc: originalDoc,
+      newDoc: tr.doc
+    });
+
     // Hoisted because it decides BOTH where the deleted widget is anchored and — since the
     // widget pins whichever end of the range it sits at — how the indicator anchors below are
     // allowed to move.
@@ -477,7 +488,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref7
       // change. Used to decide if indicator anchor positions should be adjusted
       // inward — when the widget is present the anchor must stay at the block
       // boundary to keep the indicator bar continuous with the deleted content.
-      var willRenderDeletedWidget = change.deleted.length > 0 && !((0, _isExtendedEnabled.isExtendedEnabled)(diffType) && !isInverted && hideDeletedDiffs && change.inserted.length > 0);
+      var willRenderDeletedWidget = change.deleted.length > 0 && !isMarkOnly && !((0, _isExtendedEnabled.isExtendedEnabled)(diffType) && !isInverted && hideDeletedDiffs && change.inserted.length > 0);
       if (isSmartNodeLevel) {
         // For a large inserted table, skip the O(cells) inline decorations inside the
         // table (the cell overlays added below provide the highlight without the
@@ -548,7 +559,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref7
         coarseTableCellsOnly: useCoarseTableDecoration
       }))));
     }
-    if (change.deleted.length > 0) {
+    if (change.deleted.length > 0 && !isMarkOnly) {
       var _shouldHideDeleted = (0, _isExtendedEnabled.isExtendedEnabled)(diffType) ? !isInverted && hideDeletedDiffs && change.inserted.length > 0 : false;
       if (!_shouldHideDeleted) {
         decorations.push.apply(decorations, (0, _toConsumableArray2.default)((0, _createNodeChangedDecorationWidget.createNodeChangedDecorationWidget)(_objectSpread(_objectSpread({

package/dist/cjs/pm-plugins/calculateDiff/computeDiffChanges.js

@@ -5,10 +5,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.computeDiffChanges = void 0;
 var _prosemirrorChangeset = require("prosemirror-changeset");
-var _attrAwareTokenEncoder = require("./attrAwareTokenEncoder");
 var _diffBySteps = require("./diffBySteps");
 var _groupChangesByBlock = require("./groupChangesByBlock");
 var _optimizeChanges = require("./optimizeChanges");
+var _selectTokenEncoder2 = require("./selectTokenEncoder");
 var _simplifySteps = require("./simplifySteps");
 var _classifySmartChanges = require("./smart/classifySmartChanges");
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
@@ -82,11 +82,10 @@ var computeDiffChanges = exports.computeDiffChanges = function computeDiffChange
     };
   }
 
-  // The attribute-aware encoder only affects the `smart` classification, so it is
-  // applied only for that type. (This utility intentionally applies no feature
-  // gate — see the file docstring — but a caller requesting `smart` is already
-  // behind the smart-diff gate.)
-  var tokenEncoder = diffType === 'smart' ? _attrAwareTokenEncoder.attrAwareTokenEncoder : undefined;
+  // This utility does not apply the smart-diff gate (see the file docstring); a caller
+  // requesting `smart` is already behind it.
+  var _selectTokenEncoder = (0, _selectTokenEncoder2.selectTokenEncoder)(diffType === 'smart'),
+    tokenEncoder = _selectTokenEncoder.tokenEncoder;
   var changeset = _prosemirrorChangeset.ChangeSet.create(originalDoc, undefined, tokenEncoder).addSteps(steppedDoc, stepMaps, steppedDoc);
   if (diffType === 'smart') {
     return {

package/dist/cjs/pm-plugins/calculateDiff/encodeCharacterWithMarks.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.encodeCharacterWithMarks = void 0;
+/** U+0000 cannot occur in ProseMirror text content, so a token can never be ambiguous. */
+var MARK_KEY_SEPARATOR = "\0";
+var buildMarkKey = function buildMarkKey(marks) {
+  return marks.map(function (mark) {
+    var _mark$attrs;
+    var attrs = (_mark$attrs = mark.attrs) !== null && _mark$attrs !== void 0 ? _mark$attrs : {};
+    var attrParts = Object.keys(attrs).sort().map(function (key) {
+      var _attrs$key;
+      return "".concat(key, "=").concat(JSON.stringify((_attrs$key = attrs[key]) !== null && _attrs$key !== void 0 ? _attrs$key : null));
+    });
+    return attrParts.length > 0 ? "".concat(mark.type.name, "(").concat(attrParts.join(','), ")") : mark.type.name;
+  }).sort().join('&');
+};
+
+/**
+ * Keyed on array identity: `prosemirror-changeset` passes the same `child.marks` reference for
+ * every character in a text node, so this collapses the key building to once per node.
+ */
+var markKeyCache = new WeakMap();
+
+/**
+ * Folds a character's marks into its `prosemirror-changeset` token. The library default returns
+ * only the char code, so marked and unmarked text tokenise identically and a formatting-only edit
+ * is invisible to the changeset.
+ *
+ * Marks and attrs are sorted so the token is order-independent.
+ */
+var encodeCharacterWithMarks = exports.encodeCharacterWithMarks = function encodeCharacterWithMarks(char, marks) {
+  if (marks.length === 0) {
+    return char;
+  }
+  var markKey = markKeyCache.get(marks);
+  if (markKey === undefined) {
+    markKey = buildMarkKey(marks);
+    markKeyCache.set(marks, markKey);
+  }
+  return "".concat(char).concat(MARK_KEY_SEPARATOR).concat(markKey);
+};

package/dist/cjs/pm-plugins/calculateDiff/isMarkOnlyChange.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isMarkOnlyChange = void 0;
+/** U+0000 cannot occur in ProseMirror text content, so this cannot collide with document text. */
+var NODE_MARKER = "\0";
+
+/**
+ * Node types and text only; marks and attrs excluded.
+ *
+ * Text is unprefixed so adjacent runs concatenate — a run only splits because its marks differ, so
+ * `strong("hello")` and `strong("hel") + em("lo")` must match. Attrs are excluded because a
+ * reconstructed agent edit regenerates `localId`s; `getAttrChangeRanges` reports attrs separately.
+ */
+var markFreeSignature = function markFreeSignature(doc, from, to) {
+  var parts = [];
+  doc.nodesBetween(from, to, function (node, pos) {
+    if (node.isText) {
+      var _node$text;
+      var start = Math.max(pos, from) - pos;
+      var end = Math.min(pos + node.nodeSize, to) - pos;
+      parts.push(((_node$text = node.text) !== null && _node$text !== void 0 ? _node$text : '').slice(start, end));
+    } else {
+      parts.push("".concat(NODE_MARKER).concat(node.type.name));
+    }
+    return true;
+  });
+  return parts.join('');
+};
+
+/**
+ * Whether a change differs only in marks, with identical structure and text on both sides. Only
+ * produced when a mark-aware token encoder is in use.
+ */
+var isMarkOnlyChange = exports.isMarkOnlyChange = function isMarkOnlyChange(_ref) {
+  var change = _ref.change,
+    newDoc = _ref.newDoc,
+    originalDoc = _ref.originalDoc;
+  var fromA = change.fromA,
+    toA = change.toA,
+    fromB = change.fromB,
+    toB = change.toB;
+  var isPureInsertionOrDeletion = toA === fromA || toB === fromB;
+  if (isPureInsertionOrDeletion || toA - fromA !== toB - fromB) {
+    return false;
+  }
+  return markFreeSignature(originalDoc, fromA, toA) === markFreeSignature(newDoc, fromB, toB);
+};

package/dist/cjs/pm-plugins/calculateDiff/markAwareTokenEncoder.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.markAwareTokenEncoder = void 0;
+var _encodeCharacterWithMarks = require("./encodeCharacterWithMarks");
+/** Mirrors the library's private (unexported) `typeID` so node-end tokens match. */
+var typeID = function typeID(type) {
+  var cache = type.schema.cached.changeSetIDs || (type.schema.cached.changeSetIDs = Object.create(null));
+  var id = cache[type.name];
+  if (id == null) {
+    cache[type.name] = id = Object.keys(type.schema.nodes).indexOf(type.name) + 1;
+  }
+  return id;
+};
+
+/**
+ * The library default encoder plus mark folding on text characters.
+ *
+ * Deliberately narrower than `attrAwareTokenEncoder`: node-start tokens keep the library default
+ * and do not fold in diffable attributes, which `getAttrChangeRanges` already reports for every
+ * diff type.
+ */
+var markAwareTokenEncoder = exports.markAwareTokenEncoder = {
+  encodeCharacter: function encodeCharacter(char, marks) {
+    return (0, _encodeCharacterWithMarks.encodeCharacterWithMarks)(char, marks);
+  },
+  encodeNodeStart: function encodeNodeStart(node) {
+    return node.type.name;
+  },
+  encodeNodeEnd: function encodeNodeEnd(node) {
+    return -typeID(node.type);
+  },
+  compareTokens: function compareTokens(a, b) {
+    return a === b;
+  }
+};

package/dist/cjs/pm-plugins/calculateDiff/selectTokenEncoder.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.selectTokenEncoder = void 0;
+var _fg = require("@atlaskit/platform-feature-flags/fg");
+var _attrAwareTokenEncoder = require("./attrAwareTokenEncoder");
+var _markAwareTokenEncoder = require("./markAwareTokenEncoder");
+/**
+ * Single place `platform_editor_diff_inline_mark_changes` is read, shared by
+ * `calculateDiffDecorations` and `computeDiffChanges` so the two cannot drift.
+ *
+ * With the gate off this returns what both callers computed before it existed.
+ *
+ * @param useAttrAwareEncoder Caller is running the smart classifier, which needs node attrs folded
+ * into the token.
+ */
+var selectTokenEncoder = exports.selectTokenEncoder = function selectTokenEncoder(useAttrAwareEncoder) {
+  if (useAttrAwareEncoder) {
+    return {
+      tokenEncoder: _attrAwareTokenEncoder.attrAwareTokenEncoder,
+      shouldHideMarkOnlyDeletions: false
+    };
+  }
+  if ((0, _fg.fg)('platform_editor_diff_inline_mark_changes')) {
+    return {
+      tokenEncoder: _markAwareTokenEncoder.markAwareTokenEncoder,
+      shouldHideMarkOnlyDeletions: true
+    };
+  }
+  return {
+    tokenEncoder: undefined,
+    shouldHideMarkOnlyDeletions: false
+  };
+};

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

@@ -347,7 +347,7 @@ var createNodeChangedDecorationWidget = exports.createNodeChangedDecorationWidge
       decorations.push(leftAnchor);
     }
   }
-  decorations.push(_view.Decoration.widget(safeInsertPos, dom, _objectSpread(_objectSpread({}, (0, _decorationKeys.buildDiffDecorationSpec)(_objectSpread({
+  decorations.push(_view.Decoration.widget(safeInsertPos, dom, _objectSpread(_objectSpread(_objectSpread({}, (0, _decorationKeys.buildDiffDecorationSpec)(_objectSpread({
     decorationType: 'widget',
     diffId: diffId,
     isActive: isActive,
@@ -356,7 +356,9 @@ var createNodeChangedDecorationWidget = exports.createNodeChangedDecorationWidge
     // placeBelow anchors at the end of the new content, so render on the
     // trailing side (1); otherwise render before the new content (-1).
     side: placeBelow ? 1 : -1
-  }))), {}, {
+  }))), (0, _fg.fg)('platform_editor_diff_inline_mark_changes') && {
+    marks: []
+  }), {}, {
     destroy: function destroy() {
       var _constrainMediaObserv2;
       return (_constrainMediaObserv2 = constrainMediaObserver) === null || _constrainMediaObserv2 === void 0 ? void 0 : _constrainMediaObserv2.disconnect();

package/dist/es2019/pm-plugins/calculateDiff/attrAwareTokenEncoder.js

@@ -1,5 +1,6 @@
 import { getBaseNodeTypeName } from '@atlaskit/editor-common/utils/node-type-utils';
 import { getDiffableAttrNames } from '../decorations/utils/diffableAttrs';
+import { encodeCharacterWithMarks } from './encodeCharacterWithMarks';
 
 /**
  * Attribute-aware token encoder for `prosemirror-changeset`. The default encoder
@@ -20,27 +21,6 @@ const encodeNodeWithAttrs = (node, attrNames) => {
   return `${node.type.name}|${parts.join('|')}`;
 };
 
-// Fold a character's marks (type + attrs) into its token so a formatting-only change
-// (bold/italic/link/colour, or a link whose `href` changes) registers as a real diff.
-// The default encoder returns just the char code, so marked and unmarked text tokenise
-// identically. Marks and their attrs are sorted so the token is order-independent.
-const encodeCharacterWithMarks = (char, marks) => {
-  if (marks.length === 0) {
-    // Fast path: unmarked text keeps the numeric char code (unchanged behaviour).
-    return char;
-  }
-  const markKey = marks.map(mark => {
-    var _mark$attrs;
-    const attrs = (_mark$attrs = mark.attrs) !== null && _mark$attrs !== void 0 ? _mark$attrs : {};
-    const attrParts = Object.keys(attrs).sort().map(key => {
-      var _attrs$key;
-      return `${key}=${JSON.stringify((_attrs$key = attrs[key]) !== null && _attrs$key !== void 0 ? _attrs$key : null)}`;
-    });
-    return attrParts.length > 0 ? `${mark.type.name}(${attrParts.join(',')})` : mark.type.name;
-  }).sort().join('&');
-  return `${char}\u0000${markKey}`;
-};
-
 // Like the library default, but node types with a `diffableAttrs` rule fold their
 // attrs into the open token, and text characters fold in their marks. Node-end is
 // unchanged, hence `string | number`.

package/dist/es2019/pm-plugins/calculateDiff/calculateDiffDecorations.js

@@ -17,10 +17,11 @@ import { extractDiffDescriptors } from '../decorations/decorationKeys';
 import { getAttrChangeRanges, stepIsValidAttrChange } from '../decorations/utils/getAttrChangeRanges';
 import { getMarkChangeRanges } from '../decorations/utils/getMarkChangeRanges';
 import { getDefaultDiffType, isExtendedEnabled } from '../isExtendedEnabled';
-import { attrAwareTokenEncoder } from './attrAwareTokenEncoder';
 import { diffBySteps } from './diffBySteps';
 import { groupChangesByBlock } from './groupChangesByBlock';
+import { isMarkOnlyChange } from './isMarkOnlyChange';
 import { optimizeChanges } from './optimizeChanges';
+import { selectTokenEncoder } from './selectTokenEncoder';
 import { simplifyChangesWithAttribution } from './simplifyChangesWithAttribution';
 import { simplifySteps, simplifyStepsWithAttribution } from './simplifySteps';
 import { classifySmartChanges } from './smart/classifySmartChanges';
@@ -354,10 +355,11 @@ const calculateDiffDecorationsInner = ({
       };
     }
   }
-  // The attribute-aware encoder is only needed by the smart classifier and is
-  // gated with it; other diff types keep the library default so their output is
-  // unchanged.
-  const tokenEncoder = diffType === 'smart' && fg('platform_editor_ai_smart_diff') ? attrAwareTokenEncoder : undefined;
+  // The attribute-aware encoder is only needed by the smart classifier and is gated with it.
+  const {
+    tokenEncoder,
+    shouldHideMarkOnlyDeletions
+  } = selectTokenEncoder(diffType === 'smart' && fg('platform_editor_ai_smart_diff'));
   let changes;
   let attributedChanges = [];
   let attributionColors;
@@ -409,6 +411,16 @@ const calculateDiffDecorationsInner = ({
     const changeColorScheme = attributionColors ? getColorSchemeForChange(change, attributedChanges, attributionColors, colorScheme) : colorScheme;
     const isActive = isRangeActive(activeIndexPos, change.fromB, change.toB);
 
+    // The deleted side of a mark-only change is a byte-identical copy of the new text, so it is
+    // suppressed in the clean view. `hideDeletedDiffs` is load-bearing: when false the reviewer
+    // asked to compare against the original, and the deleted side is the only place the
+    // previous formatting is visible.
+    const isMarkOnly = shouldHideMarkOnlyDeletions && hideDeletedDiffs && change.deleted.length > 0 && isMarkOnlyChange({
+      change,
+      originalDoc,
+      newDoc: tr.doc
+    });
+
     // Hoisted because it decides BOTH where the deleted widget is anchored and — since the
     // widget pins whichever end of the range it sits at — how the indicator anchors below are
     // allowed to move.
@@ -439,7 +451,7 @@ const calculateDiffDecorationsInner = ({
       // change. Used to decide if indicator anchor positions should be adjusted
       // inward — when the widget is present the anchor must stay at the block
       // boundary to keep the indicator bar continuous with the deleted content.
-      const willRenderDeletedWidget = change.deleted.length > 0 && !(isExtendedEnabled(diffType) && !isInverted && hideDeletedDiffs && change.inserted.length > 0);
+      const willRenderDeletedWidget = change.deleted.length > 0 && !isMarkOnly && !(isExtendedEnabled(diffType) && !isInverted && hideDeletedDiffs && change.inserted.length > 0);
       if (isSmartNodeLevel) {
         // For a large inserted table, skip the O(cells) inline decorations inside the
         // table (the cell overlays added below provide the highlight without the
@@ -501,7 +513,7 @@ const calculateDiffDecorationsInner = ({
         coarseTableCellsOnly: useCoarseTableDecoration
       }));
     }
-    if (change.deleted.length > 0) {
+    if (change.deleted.length > 0 && !isMarkOnly) {
       const shouldHideDeleted = isExtendedEnabled(diffType) ? !isInverted && hideDeletedDiffs && change.inserted.length > 0 : false;
       if (!shouldHideDeleted) {
         decorations.push(...createNodeChangedDecorationWidget({

package/dist/es2019/pm-plugins/calculateDiff/computeDiffChanges.js

@@ -14,10 +14,10 @@
  * reconstructed by applying the (simplified) steps to `originalDoc`.
  */
 import { ChangeSet, simplifyChanges } from 'prosemirror-changeset';
-import { attrAwareTokenEncoder } from './attrAwareTokenEncoder';
 import { diffBySteps } from './diffBySteps';
 import { groupChangesByBlock } from './groupChangesByBlock';
 import { optimizeChanges } from './optimizeChanges';
+import { selectTokenEncoder } from './selectTokenEncoder';
 import { simplifySteps } from './simplifySteps';
 import { classifySmartChanges } from './smart/classifySmartChanges';
 /**
@@ -64,11 +64,11 @@ export const computeDiffChanges = ({
     };
   }
 
-  // The attribute-aware encoder only affects the `smart` classification, so it is
-  // applied only for that type. (This utility intentionally applies no feature
-  // gate — see the file docstring — but a caller requesting `smart` is already
-  // behind the smart-diff gate.)
-  const tokenEncoder = diffType === 'smart' ? attrAwareTokenEncoder : undefined;
+  // This utility does not apply the smart-diff gate (see the file docstring); a caller
+  // requesting `smart` is already behind it.
+  const {
+    tokenEncoder
+  } = selectTokenEncoder(diffType === 'smart');
   const changeset = ChangeSet.create(originalDoc, undefined, tokenEncoder).addSteps(steppedDoc, stepMaps, steppedDoc);
   if (diffType === 'smart') {
     return {

package/dist/es2019/pm-plugins/calculateDiff/encodeCharacterWithMarks.js

@@ -0,0 +1,36 @@
+/** U+0000 cannot occur in ProseMirror text content, so a token can never be ambiguous. */
+const MARK_KEY_SEPARATOR = '\u0000';
+const buildMarkKey = marks => marks.map(mark => {
+  var _mark$attrs;
+  const attrs = (_mark$attrs = mark.attrs) !== null && _mark$attrs !== void 0 ? _mark$attrs : {};
+  const attrParts = Object.keys(attrs).sort().map(key => {
+    var _attrs$key;
+    return `${key}=${JSON.stringify((_attrs$key = attrs[key]) !== null && _attrs$key !== void 0 ? _attrs$key : null)}`;
+  });
+  return attrParts.length > 0 ? `${mark.type.name}(${attrParts.join(',')})` : mark.type.name;
+}).sort().join('&');
+
+/**
+ * Keyed on array identity: `prosemirror-changeset` passes the same `child.marks` reference for
+ * every character in a text node, so this collapses the key building to once per node.
+ */
+const markKeyCache = new WeakMap();
+
+/**
+ * Folds a character's marks into its `prosemirror-changeset` token. The library default returns
+ * only the char code, so marked and unmarked text tokenise identically and a formatting-only edit
+ * is invisible to the changeset.
+ *
+ * Marks and attrs are sorted so the token is order-independent.
+ */
+export const encodeCharacterWithMarks = (char, marks) => {
+  if (marks.length === 0) {
+    return char;
+  }
+  let markKey = markKeyCache.get(marks);
+  if (markKey === undefined) {
+    markKey = buildMarkKey(marks);
+    markKeyCache.set(marks, markKey);
+  }
+  return `${char}${MARK_KEY_SEPARATOR}${markKey}`;
+};

package/dist/es2019/pm-plugins/calculateDiff/isMarkOnlyChange.js

@@ -0,0 +1,47 @@
+/** U+0000 cannot occur in ProseMirror text content, so this cannot collide with document text. */
+const NODE_MARKER = '\u0000';
+
+/**
+ * Node types and text only; marks and attrs excluded.
+ *
+ * Text is unprefixed so adjacent runs concatenate — a run only splits because its marks differ, so
+ * `strong("hello")` and `strong("hel") + em("lo")` must match. Attrs are excluded because a
+ * reconstructed agent edit regenerates `localId`s; `getAttrChangeRanges` reports attrs separately.
+ */
+const markFreeSignature = (doc, from, to) => {
+  const parts = [];
+  doc.nodesBetween(from, to, (node, pos) => {
+    if (node.isText) {
+      var _node$text;
+      const start = Math.max(pos, from) - pos;
+      const end = Math.min(pos + node.nodeSize, to) - pos;
+      parts.push(((_node$text = node.text) !== null && _node$text !== void 0 ? _node$text : '').slice(start, end));
+    } else {
+      parts.push(`${NODE_MARKER}${node.type.name}`);
+    }
+    return true;
+  });
+  return parts.join('');
+};
+
+/**
+ * Whether a change differs only in marks, with identical structure and text on both sides. Only
+ * produced when a mark-aware token encoder is in use.
+ */
+export const isMarkOnlyChange = ({
+  change,
+  newDoc,
+  originalDoc
+}) => {
+  const {
+    fromA,
+    toA,
+    fromB,
+    toB
+  } = change;
+  const isPureInsertionOrDeletion = toA === fromA || toB === fromB;
+  if (isPureInsertionOrDeletion || toA - fromA !== toB - fromB) {
+    return false;
+  }
+  return markFreeSignature(originalDoc, fromA, toA) === markFreeSignature(newDoc, fromB, toB);
+};

package/dist/es2019/pm-plugins/calculateDiff/markAwareTokenEncoder.js

@@ -0,0 +1,25 @@
+import { encodeCharacterWithMarks } from './encodeCharacterWithMarks';
+
+/** Mirrors the library's private (unexported) `typeID` so node-end tokens match. */
+const typeID = type => {
+  const cache = type.schema.cached.changeSetIDs || (type.schema.cached.changeSetIDs = Object.create(null));
+  let id = cache[type.name];
+  if (id == null) {
+    cache[type.name] = id = Object.keys(type.schema.nodes).indexOf(type.name) + 1;
+  }
+  return id;
+};
+
+/**
+ * The library default encoder plus mark folding on text characters.
+ *
+ * Deliberately narrower than `attrAwareTokenEncoder`: node-start tokens keep the library default
+ * and do not fold in diffable attributes, which `getAttrChangeRanges` already reports for every
+ * diff type.
+ */
+export const markAwareTokenEncoder = {
+  encodeCharacter: (char, marks) => encodeCharacterWithMarks(char, marks),
+  encodeNodeStart: node => node.type.name,
+  encodeNodeEnd: node => -typeID(node.type),
+  compareTokens: (a, b) => a === b
+};

package/dist/es2019/pm-plugins/calculateDiff/selectTokenEncoder.js

@@ -0,0 +1,30 @@
+import { fg } from '@atlaskit/platform-feature-flags/fg';
+import { attrAwareTokenEncoder } from './attrAwareTokenEncoder';
+import { markAwareTokenEncoder } from './markAwareTokenEncoder';
+/**
+ * Single place `platform_editor_diff_inline_mark_changes` is read, shared by
+ * `calculateDiffDecorations` and `computeDiffChanges` so the two cannot drift.
+ *
+ * With the gate off this returns what both callers computed before it existed.
+ *
+ * @param useAttrAwareEncoder Caller is running the smart classifier, which needs node attrs folded
+ * into the token.
+ */
+export const selectTokenEncoder = useAttrAwareEncoder => {
+  if (useAttrAwareEncoder) {
+    return {
+      tokenEncoder: attrAwareTokenEncoder,
+      shouldHideMarkOnlyDeletions: false
+    };
+  }
+  if (fg('platform_editor_diff_inline_mark_changes')) {
+    return {
+      tokenEncoder: markAwareTokenEncoder,
+      shouldHideMarkOnlyDeletions: true
+    };
+  }
+  return {
+    tokenEncoder: undefined,
+    shouldHideMarkOnlyDeletions: false
+  };
+};

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

@@ -338,6 +338,13 @@ export const createNodeChangedDecorationWidget = ({
         side: placeBelow ? 1 : -1
       })
     }),
+    // Without an explicit mark set, prosemirror-view wraps the widget in the marks of the
+    // adjacent text in the NEW document. `dom` already carries the original marks, so a
+    // formatting change would render the deleted side wrapped in the very mark the edit
+    // introduced — unbolded text shown struck through but still bold.
+    ...(fg('platform_editor_diff_inline_mark_changes') && {
+      marks: []
+    }),
     destroy: () => {
       var _constrainMediaObserv2;
       return (_constrainMediaObserv2 = constrainMediaObserver) === null || _constrainMediaObserv2 === void 0 ? void 0 : _constrainMediaObserv2.disconnect();

package/dist/esm/pm-plugins/calculateDiff/attrAwareTokenEncoder.js

@@ -1,5 +1,6 @@
 import { getBaseNodeTypeName } from '@atlaskit/editor-common/utils/node-type-utils';
 import { getDiffableAttrNames } from '../decorations/utils/diffableAttrs';
+import { encodeCharacterWithMarks } from './encodeCharacterWithMarks';
 
 /**
  * Attribute-aware token encoder for `prosemirror-changeset`. The default encoder
@@ -20,27 +21,6 @@ var encodeNodeWithAttrs = function encodeNodeWithAttrs(node, attrNames) {
   return "".concat(node.type.name, "|").concat(parts.join('|'));
 };
 
-// Fold a character's marks (type + attrs) into its token so a formatting-only change
-// (bold/italic/link/colour, or a link whose `href` changes) registers as a real diff.
-// The default encoder returns just the char code, so marked and unmarked text tokenise
-// identically. Marks and their attrs are sorted so the token is order-independent.
-var encodeCharacterWithMarks = function encodeCharacterWithMarks(char, marks) {
-  if (marks.length === 0) {
-    // Fast path: unmarked text keeps the numeric char code (unchanged behaviour).
-    return char;
-  }
-  var markKey = marks.map(function (mark) {
-    var _mark$attrs;
-    var attrs = (_mark$attrs = mark.attrs) !== null && _mark$attrs !== void 0 ? _mark$attrs : {};
-    var attrParts = Object.keys(attrs).sort().map(function (key) {
-      var _attrs$key;
-      return "".concat(key, "=").concat(JSON.stringify((_attrs$key = attrs[key]) !== null && _attrs$key !== void 0 ? _attrs$key : null));
-    });
-    return attrParts.length > 0 ? "".concat(mark.type.name, "(").concat(attrParts.join(','), ")") : mark.type.name;
-  }).sort().join('&');
-  return "".concat(char, "\0").concat(markKey);
-};
-
 // Like the library default, but node types with a `diffableAttrs` rule fold their
 // attrs into the open token, and text characters fold in their marks. Node-end is
 // unchanged, hence `string | number`.

package/dist/esm/pm-plugins/calculateDiff/calculateDiffDecorations.js

@@ -25,10 +25,11 @@ import { extractDiffDescriptors } from '../decorations/decorationKeys';
 import { getAttrChangeRanges, stepIsValidAttrChange } from '../decorations/utils/getAttrChangeRanges';
 import { getMarkChangeRanges } from '../decorations/utils/getMarkChangeRanges';
 import { getDefaultDiffType, isExtendedEnabled } from '../isExtendedEnabled';
-import { attrAwareTokenEncoder } from './attrAwareTokenEncoder';
 import { diffBySteps } from './diffBySteps';
 import { groupChangesByBlock } from './groupChangesByBlock';
+import { isMarkOnlyChange } from './isMarkOnlyChange';
 import { optimizeChanges } from './optimizeChanges';
+import { selectTokenEncoder } from './selectTokenEncoder';
 import { simplifyChangesWithAttribution } from './simplifyChangesWithAttribution';
 import { simplifySteps, simplifyStepsWithAttribution } from './simplifySteps';
 import { classifySmartChanges } from './smart/classifySmartChanges';
@@ -382,10 +383,10 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref7
       };
     }
   }
-  // The attribute-aware encoder is only needed by the smart classifier and is
-  // gated with it; other diff types keep the library default so their output is
-  // unchanged.
-  var tokenEncoder = diffType === 'smart' && fg('platform_editor_ai_smart_diff') ? attrAwareTokenEncoder : undefined;
+  // The attribute-aware encoder is only needed by the smart classifier and is gated with it.
+  var _selectTokenEncoder = selectTokenEncoder(diffType === 'smart' && fg('platform_editor_ai_smart_diff')),
+    tokenEncoder = _selectTokenEncoder.tokenEncoder,
+    shouldHideMarkOnlyDeletions = _selectTokenEncoder.shouldHideMarkOnlyDeletions;
   var changes;
   var attributedChanges = [];
   var attributionColors;
@@ -440,6 +441,16 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref7
     var changeColorScheme = attributionColors ? getColorSchemeForChange(change, attributedChanges, attributionColors, colorScheme) : colorScheme;
     var isActive = isRangeActive(activeIndexPos, change.fromB, change.toB);
 
+    // The deleted side of a mark-only change is a byte-identical copy of the new text, so it is
+    // suppressed in the clean view. `hideDeletedDiffs` is load-bearing: when false the reviewer
+    // asked to compare against the original, and the deleted side is the only place the
+    // previous formatting is visible.
+    var isMarkOnly = shouldHideMarkOnlyDeletions && hideDeletedDiffs && change.deleted.length > 0 && isMarkOnlyChange({
+      change: change,
+      originalDoc: originalDoc,
+      newDoc: tr.doc
+    });
+
     // Hoisted because it decides BOTH where the deleted widget is anchored and — since the
     // widget pins whichever end of the range it sits at — how the indicator anchors below are
     // allowed to move.
@@ -470,7 +481,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref7
       // change. Used to decide if indicator anchor positions should be adjusted
       // inward — when the widget is present the anchor must stay at the block
       // boundary to keep the indicator bar continuous with the deleted content.
-      var willRenderDeletedWidget = change.deleted.length > 0 && !(isExtendedEnabled(diffType) && !isInverted && hideDeletedDiffs && change.inserted.length > 0);
+      var willRenderDeletedWidget = change.deleted.length > 0 && !isMarkOnly && !(isExtendedEnabled(diffType) && !isInverted && hideDeletedDiffs && change.inserted.length > 0);
       if (isSmartNodeLevel) {
         // For a large inserted table, skip the O(cells) inline decorations inside the
         // table (the cell overlays added below provide the highlight without the
@@ -541,7 +552,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref7
         coarseTableCellsOnly: useCoarseTableDecoration
       }))));
     }
-    if (change.deleted.length > 0) {
+    if (change.deleted.length > 0 && !isMarkOnly) {
       var _shouldHideDeleted = isExtendedEnabled(diffType) ? !isInverted && hideDeletedDiffs && change.inserted.length > 0 : false;
       if (!_shouldHideDeleted) {
         decorations.push.apply(decorations, _toConsumableArray(createNodeChangedDecorationWidget(_objectSpread(_objectSpread({

package/dist/esm/pm-plugins/calculateDiff/computeDiffChanges.js

@@ -17,10 +17,10 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  * reconstructed by applying the (simplified) steps to `originalDoc`.
  */
 import { ChangeSet, simplifyChanges } from 'prosemirror-changeset';
-import { attrAwareTokenEncoder } from './attrAwareTokenEncoder';
 import { diffBySteps } from './diffBySteps';
 import { groupChangesByBlock } from './groupChangesByBlock';
 import { optimizeChanges } from './optimizeChanges';
+import { selectTokenEncoder } from './selectTokenEncoder';
 import { simplifySteps } from './simplifySteps';
 import { classifySmartChanges } from './smart/classifySmartChanges';
 /**
@@ -77,11 +77,10 @@ export var computeDiffChanges = function computeDiffChanges(_ref) {
     };
   }
 
-  // The attribute-aware encoder only affects the `smart` classification, so it is
-  // applied only for that type. (This utility intentionally applies no feature
-  // gate — see the file docstring — but a caller requesting `smart` is already
-  // behind the smart-diff gate.)
-  var tokenEncoder = diffType === 'smart' ? attrAwareTokenEncoder : undefined;
+  // This utility does not apply the smart-diff gate (see the file docstring); a caller
+  // requesting `smart` is already behind it.
+  var _selectTokenEncoder = selectTokenEncoder(diffType === 'smart'),
+    tokenEncoder = _selectTokenEncoder.tokenEncoder;
   var changeset = ChangeSet.create(originalDoc, undefined, tokenEncoder).addSteps(steppedDoc, stepMaps, steppedDoc);
   if (diffType === 'smart') {
     return {

package/dist/esm/pm-plugins/calculateDiff/encodeCharacterWithMarks.js

@@ -0,0 +1,38 @@
+/** U+0000 cannot occur in ProseMirror text content, so a token can never be ambiguous. */
+var MARK_KEY_SEPARATOR = "\0";
+var buildMarkKey = function buildMarkKey(marks) {
+  return marks.map(function (mark) {
+    var _mark$attrs;
+    var attrs = (_mark$attrs = mark.attrs) !== null && _mark$attrs !== void 0 ? _mark$attrs : {};
+    var attrParts = Object.keys(attrs).sort().map(function (key) {
+      var _attrs$key;
+      return "".concat(key, "=").concat(JSON.stringify((_attrs$key = attrs[key]) !== null && _attrs$key !== void 0 ? _attrs$key : null));
+    });
+    return attrParts.length > 0 ? "".concat(mark.type.name, "(").concat(attrParts.join(','), ")") : mark.type.name;
+  }).sort().join('&');
+};
+
+/**
+ * Keyed on array identity: `prosemirror-changeset` passes the same `child.marks` reference for
+ * every character in a text node, so this collapses the key building to once per node.
+ */
+var markKeyCache = new WeakMap();
+
+/**
+ * Folds a character's marks into its `prosemirror-changeset` token. The library default returns
+ * only the char code, so marked and unmarked text tokenise identically and a formatting-only edit
+ * is invisible to the changeset.
+ *
+ * Marks and attrs are sorted so the token is order-independent.
+ */
+export var encodeCharacterWithMarks = function encodeCharacterWithMarks(char, marks) {
+  if (marks.length === 0) {
+    return char;
+  }
+  var markKey = markKeyCache.get(marks);
+  if (markKey === undefined) {
+    markKey = buildMarkKey(marks);
+    markKeyCache.set(marks, markKey);
+  }
+  return "".concat(char).concat(MARK_KEY_SEPARATOR).concat(markKey);
+};

package/dist/esm/pm-plugins/calculateDiff/isMarkOnlyChange.js

@@ -0,0 +1,44 @@
+/** U+0000 cannot occur in ProseMirror text content, so this cannot collide with document text. */
+var NODE_MARKER = "\0";
+
+/**
+ * Node types and text only; marks and attrs excluded.
+ *
+ * Text is unprefixed so adjacent runs concatenate — a run only splits because its marks differ, so
+ * `strong("hello")` and `strong("hel") + em("lo")` must match. Attrs are excluded because a
+ * reconstructed agent edit regenerates `localId`s; `getAttrChangeRanges` reports attrs separately.
+ */
+var markFreeSignature = function markFreeSignature(doc, from, to) {
+  var parts = [];
+  doc.nodesBetween(from, to, function (node, pos) {
+    if (node.isText) {
+      var _node$text;
+      var start = Math.max(pos, from) - pos;
+      var end = Math.min(pos + node.nodeSize, to) - pos;
+      parts.push(((_node$text = node.text) !== null && _node$text !== void 0 ? _node$text : '').slice(start, end));
+    } else {
+      parts.push("".concat(NODE_MARKER).concat(node.type.name));
+    }
+    return true;
+  });
+  return parts.join('');
+};
+
+/**
+ * Whether a change differs only in marks, with identical structure and text on both sides. Only
+ * produced when a mark-aware token encoder is in use.
+ */
+export var isMarkOnlyChange = function isMarkOnlyChange(_ref) {
+  var change = _ref.change,
+    newDoc = _ref.newDoc,
+    originalDoc = _ref.originalDoc;
+  var fromA = change.fromA,
+    toA = change.toA,
+    fromB = change.fromB,
+    toB = change.toB;
+  var isPureInsertionOrDeletion = toA === fromA || toB === fromB;
+  if (isPureInsertionOrDeletion || toA - fromA !== toB - fromB) {
+    return false;
+  }
+  return markFreeSignature(originalDoc, fromA, toA) === markFreeSignature(newDoc, fromB, toB);
+};

package/dist/esm/pm-plugins/calculateDiff/markAwareTokenEncoder.js

@@ -0,0 +1,33 @@
+import { encodeCharacterWithMarks } from './encodeCharacterWithMarks';
+
+/** Mirrors the library's private (unexported) `typeID` so node-end tokens match. */
+var typeID = function typeID(type) {
+  var cache = type.schema.cached.changeSetIDs || (type.schema.cached.changeSetIDs = Object.create(null));
+  var id = cache[type.name];
+  if (id == null) {
+    cache[type.name] = id = Object.keys(type.schema.nodes).indexOf(type.name) + 1;
+  }
+  return id;
+};
+
+/**
+ * The library default encoder plus mark folding on text characters.
+ *
+ * Deliberately narrower than `attrAwareTokenEncoder`: node-start tokens keep the library default
+ * and do not fold in diffable attributes, which `getAttrChangeRanges` already reports for every
+ * diff type.
+ */
+export var markAwareTokenEncoder = {
+  encodeCharacter: function encodeCharacter(char, marks) {
+    return encodeCharacterWithMarks(char, marks);
+  },
+  encodeNodeStart: function encodeNodeStart(node) {
+    return node.type.name;
+  },
+  encodeNodeEnd: function encodeNodeEnd(node) {
+    return -typeID(node.type);
+  },
+  compareTokens: function compareTokens(a, b) {
+    return a === b;
+  }
+};

package/dist/esm/pm-plugins/calculateDiff/selectTokenEncoder.js

@@ -0,0 +1,30 @@
+import { fg } from '@atlaskit/platform-feature-flags/fg';
+import { attrAwareTokenEncoder } from './attrAwareTokenEncoder';
+import { markAwareTokenEncoder } from './markAwareTokenEncoder';
+/**
+ * Single place `platform_editor_diff_inline_mark_changes` is read, shared by
+ * `calculateDiffDecorations` and `computeDiffChanges` so the two cannot drift.
+ *
+ * With the gate off this returns what both callers computed before it existed.
+ *
+ * @param useAttrAwareEncoder Caller is running the smart classifier, which needs node attrs folded
+ * into the token.
+ */
+export var selectTokenEncoder = function selectTokenEncoder(useAttrAwareEncoder) {
+  if (useAttrAwareEncoder) {
+    return {
+      tokenEncoder: attrAwareTokenEncoder,
+      shouldHideMarkOnlyDeletions: false
+    };
+  }
+  if (fg('platform_editor_diff_inline_mark_changes')) {
+    return {
+      tokenEncoder: markAwareTokenEncoder,
+      shouldHideMarkOnlyDeletions: true
+    };
+  }
+  return {
+    tokenEncoder: undefined,
+    shouldHideMarkOnlyDeletions: false
+  };
+};

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

@@ -340,7 +340,7 @@ export var createNodeChangedDecorationWidget = function createNodeChangedDecorat
       decorations.push(leftAnchor);
     }
   }
-  decorations.push(Decoration.widget(safeInsertPos, dom, _objectSpread(_objectSpread({}, buildDiffDecorationSpec(_objectSpread({
+  decorations.push(Decoration.widget(safeInsertPos, dom, _objectSpread(_objectSpread(_objectSpread({}, buildDiffDecorationSpec(_objectSpread({
     decorationType: 'widget',
     diffId: diffId,
     isActive: isActive,
@@ -349,7 +349,9 @@ export var createNodeChangedDecorationWidget = function createNodeChangedDecorat
     // placeBelow anchors at the end of the new content, so render on the
     // trailing side (1); otherwise render before the new content (-1).
     side: placeBelow ? 1 : -1
-  }))), {}, {
+  }))), fg('platform_editor_diff_inline_mark_changes') && {
+    marks: []
+  }), {}, {
     destroy: function destroy() {
       var _constrainMediaObserv2;
       return (_constrainMediaObserv2 = constrainMediaObserver) === null || _constrainMediaObserv2 === void 0 ? void 0 : _constrainMediaObserv2.disconnect();

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

@@ -0,0 +1,9 @@
+import type { Mark } from '@atlaskit/editor-prosemirror/model';
+/**
+ * Folds a character's marks into its `prosemirror-changeset` token. The library default returns
+ * only the char code, so marked and unmarked text tokenise identically and a formatting-only edit
+ * is invisible to the changeset.
+ *
+ * Marks and attrs are sorted so the token is order-independent.
+ */
+export declare const encodeCharacterWithMarks: (char: number, marks: readonly Mark[]) => number | string;

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

@@ -0,0 +1,15 @@
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+/**
+ * Whether a change differs only in marks, with identical structure and text on both sides. Only
+ * produced when a mark-aware token encoder is in use.
+ */
+export declare const isMarkOnlyChange: ({ change, newDoc, originalDoc, }: {
+    change: {
+        fromA: number;
+        fromB: number;
+        toA: number;
+        toB: number;
+    };
+    newDoc: PMNode;
+    originalDoc: PMNode;
+}) => boolean;

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

@@ -0,0 +1,9 @@
+import type { TokenEncoder } from 'prosemirror-changeset';
+/**
+ * The library default encoder plus mark folding on text characters.
+ *
+ * Deliberately narrower than `attrAwareTokenEncoder`: node-start tokens keep the library default
+ * and do not fold in diffable attributes, which `getAttrChangeRanges` already reports for every
+ * diff type.
+ */
+export declare const markAwareTokenEncoder: TokenEncoder<string | number>;

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

@@ -0,0 +1,17 @@
+import type { TokenEncoder } from 'prosemirror-changeset';
+export type TokenEncoderSelection = {
+    /** Non-smart mark-aware path only; lets callers suppress a duplicate deleted side. */
+    shouldHideMarkOnlyDeletions: boolean;
+    /** Encoder to hand to `ChangeSet.create`. `undefined` means the library default. */
+    tokenEncoder: TokenEncoder<string | number> | undefined;
+};
+/**
+ * Single place `platform_editor_diff_inline_mark_changes` is read, shared by
+ * `calculateDiffDecorations` and `computeDiffChanges` so the two cannot drift.
+ *
+ * With the gate off this returns what both callers computed before it existed.
+ *
+ * @param useAttrAwareEncoder Caller is running the smart classifier, which needs node attrs folded
+ * into the token.
+ */
+export declare const selectTokenEncoder: (useAttrAwareEncoder: boolean) => TokenEncoderSelection;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-show-diff",
-	"version": "14.2.10",
+	"version": "14.2.11",
 	"description": "ShowDiff plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -28,7 +28,7 @@
 		"@atlaskit/editor-tables": "^3.1.0",
 		"@atlaskit/platform-feature-experiments": "^0.3.0",
 		"@atlaskit/platform-feature-flags": "^2.2.0",
-		"@atlaskit/tmp-editor-statsig": "^171.0.0",
+		"@atlaskit/tmp-editor-statsig": "^172.0.0",
 		"@atlaskit/tokens": "^16.11.0",
 		"@babel/runtime": "^7.0.0",
 		"@compiled/react": "^1.0.2",
@@ -59,45 +59,9 @@
 		"react-intl": "^7.0.0"
 	},
 	"peerDependencies": {
-		"@atlaskit/editor-common": "^120.10.0",
+		"@atlaskit/editor-common": "^120.11.0",
 		"react": "^18.2.0 || ^19.2.0"
 	},
-	"techstack": {
-		"@atlassian/frontend": {
-			"code-structure": [
-				"editor-plugin"
-			],
-			"import-structure": [
-				"atlassian-conventions"
-			],
-			"circular-dependencies": [
-				"file-and-folder-level"
-			]
-		},
-		"@repo/internal": {
-			"dom-events": "use-bind-event-listener",
-			"analytics": [
-				"analytics-next"
-			],
-			"design-tokens": [
-				"color"
-			],
-			"theming": [
-				"react-context"
-			],
-			"ui-components": [
-				"lite-mode"
-			],
-			"deprecation": "no-deprecated-imports",
-			"styling": [
-				"emotion",
-				"emotion"
-			],
-			"imports": [
-				"import-no-extraneous-disable-for-examples-and-docs"
-			]
-		}
-	},
 	"platform-feature-flags": {
 		"platform_editor_ai_show_diff_patch_1": {
 			"type": "boolean"
@@ -110,6 +74,9 @@
 		},
 		"platform_editor_reduce_diff_attr_sensitivity": {
 			"type": "boolean"
+		},
+		"platform_editor_diff_inline_mark_changes": {
+			"type": "boolean"
 		}
 	}
 }