@atlaskit/editor-common 122.5.0 → 122.6.0

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # @atlaskit/editor-common
 
+## 122.6.0
+
+### Minor Changes
+
+- [`b9d1af39046dc`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/b9d1af39046dc) -
+  Add a shared applied-step range detector for AI activity. Connect local streaming under
+  platform_editor_ai_streaming_ux_experience_m1 and incoming agent edits under the existing backend
+  streaming rollout to this detector. Refine shared chrome highlights to affected nested textblock
+  content for all existing shared-chrome consumers.
+
+  Preserve node attribute activity through cumulative replacements that retain its markup while
+  changing descendant content. Reuse existing highlight styles and the grouped cursor.
+
+  Expose a transaction-only AI activity action and connect direct orchestrator attribute, move, wrap
+  and remove mutations under platform_editor_ai_streaming_ux_experience_m1. Keep review segments and
+  existing streaming cadence unchanged.
+
+  Reuse lazily built node-identity indexes per transaction snapshot to avoid repeated full-document
+  lookups when changed blocks survive cumulative replacements.
+
+  Let the chrome plugin map and accumulate existing highlights without restamping stale positions
+  from before direct orchestrator mutations.
+
+- [`276b5526e198a`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/276b5526e198a) -
+  Show the user profile card on hover in the mentions typeahead, behind the
+  `platform_editor_mention_typeahead_user_profilecard` experiment
+
+### Patch Changes
+
+- [`9e6211ceb4ceb`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/9e6211ceb4ceb) -
+  Clean up the fully rolled-out `platform_editor_small_font_size` experiment and make its permanent
+  `true` behavior unconditional across editor formatting, task and list handling, paste behavior,
+  controls, and rendering.
+- Updated dependencies
+
 ## 122.5.0
 
 ### Minor Changes

package/collab-agent-edit-changed-ranges/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@atlaskit/editor-common/collab-agent-edit-changed-ranges",
+  "main": "../dist/cjs/collab/agent-edit-changed-ranges.js",
+  "module": "../dist/esm/collab/agent-edit-changed-ranges.js",
+  "module:es2019": "../dist/es2019/collab/agent-edit-changed-ranges.js",
+  "sideEffects": [
+    "**/*.compiled.css"
+  ],
+  "types": "../dist/types/collab/agent-edit-changed-ranges.d.ts"
+}

package/dist/cjs/collab/agent-edit-changed-ranges.js

@@ -0,0 +1,304 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAgentEditChangedRanges = getAgentEditChangedRanges;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
+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; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+// localId is identity metadata: regenerating it alone should not create activity.
+var sameAttrs = function sameAttrs(left, right) {
+  var keys = Object.keys(left).filter(function (key) {
+    return key !== 'localId';
+  });
+  return keys.length === Object.keys(right).filter(function (key) {
+    return key !== 'localId';
+  }).length && keys.every(function (key) {
+    return (0, _isEqual.default)(left[key], right[key]);
+  });
+};
+
+// Compare the node's own type, attributes and marks, without comparing its children.
+var sameMarkup = function sameMarkup(left, right) {
+  return left.type === right.type && sameAttrs(left.attrs, right.attrs) && left.marks.length === right.marks.length && left.marks.every(function (mark, index) {
+    return mark.type === right.marks[index].type && sameAttrs(mark.attrs, right.marks[index].attrs);
+  });
+};
+var _sameNode = function sameNode(left, right) {
+  if (left === right) {
+    return true;
+  }
+  if (!sameMarkup(left, right) || left.text !== right.text || left.childCount !== right.childCount) {
+    return false;
+  }
+  for (var index = 0; index < left.childCount; index++) {
+    if (!_sameNode(left.child(index), right.child(index))) {
+      return false;
+    }
+  }
+  return true;
+};
+
+// Positions include document structure, not just character offsets. A non-leaf node
+// uses one position for each opening/closing boundary, plus the size of its content.
+// Example: paragraph('Hi') at pos 0 has nodeSize 4, outer range [0, 4),
+// and text content [1, 3). All ranges here use an exclusive end position.
+
+// Keep the reason internally so a panel attribute change can survive child edits.
+// Only ordinary { from, to } ranges are returned to the chrome consumer.
+
+var _collectChanges = function collectChanges(before, after, map, ranges) {
+  var node = after.node,
+    pos = after.pos;
+  if (before && _sameNode(before.node, node)) {
+    return;
+  }
+  // Text edits belong to their textblock. A node's own markup change instead
+  // owns its full content, so we stop here rather than adding child ranges too.
+  var markupChanged = !!before && node.isBlock && !sameMarkup(before.node, node);
+  if (node.isTextblock || markupChanged) {
+    if (node.content.size > 0) {
+      ranges.push({
+        from: pos,
+        to: pos + node.nodeSize,
+        markupChanged: markupChanged
+      });
+    }
+    return;
+  }
+  var byPosition = new Map();
+  var byId = new Map();
+  var oldChildren = [];
+  before === null || before === void 0 || before.node.forEach(function (child, offset) {
+    // forEach offsets start inside the parent. Skip its opening boundary (+1)
+    // to convert this child offset into an absolute document position.
+    var previous = {
+      node: child,
+      pos: before.pos + 1 + offset
+    };
+    oldChildren.push(previous);
+    // This 1 is a mapping bias, not an added offset: follow the right side
+    // of an insertion at the child's start, keeping the original child after it.
+    var mapped = map.mapResult(previous.pos, 1);
+    if (!mapped.deleted) {
+      byPosition.set(mapped.pos, previous);
+    }
+    var id = child.attrs.localId;
+    if (typeof id === 'string' && id) {
+      // Duplicate IDs cannot identify a unique old child.
+      byId.set(id, byId.has(id) ? null : previous);
+    }
+  });
+  var nextChildren = [];
+  node.forEach(function (child, offset) {
+    return nextChildren.push({
+      node: child,
+      pos: pos + 1 + offset
+    });
+  });
+  // Narrow edits usually preserve mapped positions. Whole-container replacements
+  // may erase those positions, so stable child IDs provide a second way to match.
+  var preferred = nextChildren.map(function (next) {
+    var _ref, _byPosition$get;
+    return (_ref = (_byPosition$get = byPosition.get(next.pos)) !== null && _byPosition$get !== void 0 ? _byPosition$get : byId.get(next.node.attrs.localId)) !== null && _ref !== void 0 ? _ref : undefined;
+  });
+  var claims = new Map();
+  var _iterator = _createForOfIteratorHelper(preferred),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var match = _step.value;
+      if (match) {
+        var _claims$get;
+        claims.set(match, ((_claims$get = claims.get(match)) !== null && _claims$get !== void 0 ? _claims$get : 0) + 1);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  nextChildren.forEach(function (next, index) {
+    var match = preferred[index];
+    // Same-index fallback supports replacements that regenerate IDs but keep
+    // the child structure. Different child counts make that correspondence unsafe.
+    var aligned = oldChildren.length === node.childCount ? oldChildren[index] : undefined;
+    // Reserve every position/ID match before fallback, including later siblings.
+    // Reusing one old sibling can otherwise disguise an equal-text insertion.
+    var previous = match && claims.get(match) === 1 ? match : aligned && !claims.has(aligned) ? aligned : undefined;
+    _collectChanges(previous, next, map, ranges);
+  });
+};
+var findPreservedNode = function findPreservedNode(doc, previous, markupChanged, indexes) {
+  var id = previous.attrs.localId;
+  if (typeof id !== 'string' || !id) {
+    return;
+  }
+  var byId = indexes.get(doc);
+  if (!byId) {
+    // Build only when mapping loses a candidate, then reuse for every range
+    // visiting this immutable snapshot. Ordinary mapped edits need no scan.
+    var nodeIndex = new Map();
+    doc.descendants(function (node, pos) {
+      var localId = node.attrs.localId;
+      if (typeof localId === 'string' && localId) {
+        // Keep duplicates ambiguous, including IDs outside the changed subtree.
+        nodeIndex.set(localId, nodeIndex.has(localId) ? null : {
+          node: node,
+          pos: pos
+        });
+      }
+    });
+    indexes.set(doc, nodeIndex);
+    byId = nodeIndex;
+  }
+  var match = byId.get(id);
+  // Attribute/mark activity belongs to the node even when its children are edited.
+  // Content-only activity still requires the entire candidate to survive unchanged.
+  var isPreserved = markupChanged ? sameMarkup : _sameNode;
+  return match && isPreserved(previous, match.node) ? match : undefined;
+};
+var mapToFinalBlocks = function mapToFinalBlocks(tr, index, range, indexes) {
+  var _tr$docs;
+  var from = range.from,
+    to = range.to;
+  // Track inner content separately from outer node bounds: +1 skips the opening
+  // boundary and -1 excludes the closing boundary (see paragraph example above).
+  var contentFrom = from + 1;
+  var contentTo = to - 1;
+  // docs[i] is the document BEFORE step i, so docs[i + 1] is its result.
+  // The last step has no next snapshot; tr.doc is its result instead.
+  var node = ((_tr$docs = tr.docs[index + 1]) !== null && _tr$docs !== void 0 ? _tr$docs : tr.doc).nodeAt(from);
+  if (!node) {
+    return [];
+  }
+  // Later non-AI steps also shift/delete existing activity, even though they
+  // cannot create new activity themselves. Process every intermediate document.
+  for (var next = index + 1; next < tr.steps.length; next++) {
+    var _tr$docs2;
+    var map = tr.mapping.maps[next];
+    var after = (_tr$docs2 = tr.docs[next + 1]) !== null && _tr$docs2 !== void 0 ? _tr$docs2 : tr.doc;
+    // Mapping biases +1 (right) and -1 (left) keep boundary insertions outside
+    // the tracked content. These arguments do not add/subtract document positions.
+    var start = map.mapResult(contentFrom, 1);
+    var end = map.mapResult(contentTo, -1);
+    if (start.deleted && end.deleted || end.pos <= start.pos) {
+      // A cumulative replacement can preserve the candidate content or owned markup.
+      // Check every intermediate doc so deletion then reinsertion never resurrects it.
+      var preserved = findPreservedNode(after, node, range.markupChanged, indexes);
+      if (!preserved) {
+        return [];
+      }
+      from = preserved.pos;
+      to = from + preserved.node.nodeSize;
+      contentFrom = from + 1;
+      contentTo = to - 1;
+      node = preserved.node;
+    } else {
+      // Apply the same inward biases to the outer node bounds.
+      from = map.map(from, 1);
+      to = map.map(to, -1);
+      contentFrom = start.pos;
+      contentTo = end.pos;
+      var current = after.nodeAt(from);
+      if (current && current.nodeSize === to - from) {
+        node = current;
+      }
+    }
+  }
+  if (from < 0 || to > tr.doc.content.size || contentTo <= contentFrom) {
+    return [];
+  }
+  var finalNode = tr.doc.nodeAt(from);
+  if (finalNode !== null && finalNode !== void 0 && finalNode.isBlock && finalNode.nodeSize === to - from) {
+    return [{
+      from: from,
+      to: to
+    }];
+  }
+  // Joins/splits can leave mapped boundaries inside the final textblock.
+  var blocks = [];
+  tr.doc.nodesBetween(contentFrom, contentTo, function (child, pos) {
+    if (child.isTextblock) {
+      blocks.push({
+        from: pos,
+        to: pos + child.nodeSize
+      });
+      return false;
+    }
+  });
+  return blocks;
+};
+
+/**
+ * Returns whole content-block ranges for selected applied steps, in tr.doc coordinates.
+ * Callers select actual AI writes (excluding restores, acknowledgments and preparation)
+ * and own experiment/lifecycle decisions. This helper does not dispatch or render.
+ *
+ * Comparing each step's snapshots also handles attribute/mark steps with empty maps.
+ * Shared unchanged subtrees are skipped by reference. Only localId changes are ignored;
+ * meaningful attributes and marks retain the affected node's full content scope.
+ */
+function getAgentEditChangedRanges(tr, includedStepIndexes) {
+  // Positions belong to each intermediate document, not just tr.doc. Keep the
+  // lazy indexes local to this call so deletion/reinsertion checks stay intact
+  // and no cache is retained between transactions or streaming chunks.
+  var indexes = new WeakMap();
+  var ranges = [];
+  var _iterator2 = _createForOfIteratorHelper(new Set(includedStepIndexes)),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _tr$docs3;
+      var index = _step2.value;
+      if (!Number.isInteger(index) || index < 0 || index >= tr.steps.length) {
+        continue;
+      }
+      var changed = [];
+      // The root document has no opening boundary. Using -1 makes the recursive
+      // parent.pos + 1 + offset formula place its first child at position 0.
+      _collectChanges({
+        node: tr.docs[index],
+        pos: -1
+      }, {
+        node: (_tr$docs3 = tr.docs[index + 1]) !== null && _tr$docs3 !== void 0 ? _tr$docs3 : tr.doc,
+        pos: -1
+      }, tr.steps[index].getMap(), changed);
+      for (var _i = 0, _changed = changed; _i < _changed.length; _i++) {
+        var range = _changed[_i];
+        ranges.push.apply(ranges, (0, _toConsumableArray2.default)(mapToFinalBlocks(tr, index, range, indexes)));
+      }
+    }
+
+    // Return only the surviving final-document ranges, never intermediate step states.
+    // Sort outer ranges before their children, then discard duplicates/contained ranges.
+    // Separate ranges stay separate; this must not highlight the untouched gaps.
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  var unique = [];
+  var _iterator3 = _createForOfIteratorHelper(ranges.sort(function (left, right) {
+      return left.from - right.from || right.to - left.to;
+    })),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var _range = _step3.value;
+      var previous = unique[unique.length - 1];
+      if (!previous || _range.to > previous.to) {
+        unique.push(_range);
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  return unique;
+}

package/dist/cjs/monitoring/error.js

@@ -27,7 +27,7 @@ var NETWORK_FAILURE_REGEX = /^network failure/i;
 var RESIZE_OBSERVER_LOOP_REGEX = /ResizeObserver loop completed with undelivered notifications/;
 var SENTRY_DSN = 'https://0b10c8e02fb44d8796c047b102c9bee8@o55978.ingest.sentry.io/4505129224110080';
 var packageName = 'editor-common'; // Sentry doesn't accept '/' in its releases https://docs.sentry.io/platforms/javascript/configuration/releases/
-var packageVersion = "122.4.0";
+var packageVersion = "122.5.0";
 var sanitiseSentryEvents = function sanitiseSentryEvents(data, _hint) {
   // Remove URL as it has UGC
   // Ignored via go/ees007

package/dist/cjs/transforms/getFormattedNode.js

@@ -5,14 +5,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getFormattedNode = void 0;
 var _utils = require("@atlaskit/editor-prosemirror/utils");
-var _expValEquals = require("@atlaskit/tmp-editor-statsig/exp-val-equals");
 var getFormattedNode = exports.getFormattedNode = function getFormattedNode(tr) {
   var selection = tr.selection;
   var nodes = tr.doc.type.schema.nodes;
-
-  // gating behind platform_editor_small_font_size to support task lists with font size applied,
-  // but keep this solution general
-  var isBlockTaskItemEnabled = !!nodes.blockTaskItem && (0, _expValEquals.expValEquals)('platform_editor_small_font_size', 'isEnabled', true);
+  var isBlockTaskItemEnabled = !!nodes.blockTaskItem;
 
   // Find the node to format from the current selection
   var nodeToFormat;

package/dist/cjs/transforms/list-transforms.js

@@ -39,7 +39,6 @@ exports.transformToTaskList = void 0;
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _model = require("@atlaskit/editor-prosemirror/model");
-var _expValEquals = require("@atlaskit/tmp-editor-statsig/exp-val-equals");
 var _convertBlockToInlineContent = require("./convertBlockToInlineContent");
 var _createBlockTaskItem = require("./createBlockTaskItem");
 var _isBulletOrOrderedList = require("./isBulletOrOrderedList");
@@ -76,10 +75,7 @@ var _transformListRecursively = exports.transformListRecursively = function tran
     taskItem = _schema$nodes.taskItem,
     paragraph = _schema$nodes.paragraph,
     blockTaskItem = _schema$nodes.blockTaskItem;
-
-  // gating behind platform_editor_small_font_size to support task lists with font size applied,
-  // but keep this solution general
-  var isBlockTaskEnabled = !!blockTaskItem && (0, _expValEquals.expValEquals)('platform_editor_small_font_size', 'isEnabled', true);
+  var isBlockTaskEnabled = !!blockTaskItem;
 
   /**
    * Extracts paragraph children from a blockTaskItem, preserving their marks.
@@ -239,9 +235,7 @@ var transformToTaskList = exports.transformToTaskList = function transformToTask
     var taskItem = nodes.taskItem,
       paragraph = nodes.paragraph,
       blockTaskItem = nodes.blockTaskItem;
-    // gating behind platform_editor_small_font_size to support task lists with font size applied,
-    // but keep this solution general
-    var isBlockTaskItemEnabled = !!blockTaskItem && (0, _expValEquals.expValEquals)('platform_editor_small_font_size', 'isEnabled', true);
+    var isBlockTaskItemEnabled = !!blockTaskItem;
     var listItems = [];
 
     // Process each block in the range

package/dist/cjs/transforms/transformTaskListToBlockNodes.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", {
 exports.transformTaskListToBlockNodes = void 0;
 var _model = require("@atlaskit/editor-prosemirror/model");
 var _utils = require("@atlaskit/editor-prosemirror/utils");
-var _expValEquals = require("@atlaskit/tmp-editor-statsig/exp-val-equals");
 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; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
@@ -19,10 +18,7 @@ var transformTaskListToBlockNodes = exports.transformTaskListToBlockNodes = func
   var selection = tr.selection;
   var schema = selection.$from.doc.type.schema;
   var blockTaskItem = schema.nodes.blockTaskItem;
-
-  // gating behind platform_editor_small_font_size to support task lists with font size applied,
-  // but keep this solution general
-  var isBlockTaskItemEnabled = !!blockTaskItem && (0, _expValEquals.expValEquals)('platform_editor_small_font_size', 'isEnabled', true);
+  var isBlockTaskItemEnabled = !!blockTaskItem;
   if (isBlockTaskItemEnabled) {
     var blockTaskItemsResult = (0, _utils.findChildrenByType)(sourceNode, blockTaskItem);
     if (blockTaskItemsResult.length > 0 && targetNodeType === schema.nodes.paragraph) {

package/dist/cjs/ui/DropList/index.js

@@ -24,7 +24,7 @@ function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.
  * @jsx jsx
  */ // eslint-disable-next-line @atlaskit/ui-styling-standard/use-compiled -- Ignored via go/DSP-18766
 var packageName = "@atlaskit/editor-common";
-var packageVersion = "122.4.0";
+var packageVersion = "122.5.0";
 var halfFocusRing = 1;
 var dropOffset = '0, 8';
 var fadeIn = (0, _react2.keyframes)({

package/dist/es2019/collab/agent-edit-changed-ranges.js

@@ -0,0 +1,255 @@
+import isEqual from 'lodash/isEqual';
+// localId is identity metadata: regenerating it alone should not create activity.
+const sameAttrs = (left, right) => {
+  const keys = Object.keys(left).filter(key => key !== 'localId');
+  return keys.length === Object.keys(right).filter(key => key !== 'localId').length && keys.every(key => isEqual(left[key], right[key]));
+};
+
+// Compare the node's own type, attributes and marks, without comparing its children.
+const sameMarkup = (left, right) => left.type === right.type && sameAttrs(left.attrs, right.attrs) && left.marks.length === right.marks.length && left.marks.every((mark, index) => mark.type === right.marks[index].type && sameAttrs(mark.attrs, right.marks[index].attrs));
+const sameNode = (left, right) => {
+  if (left === right) {
+    return true;
+  }
+  if (!sameMarkup(left, right) || left.text !== right.text || left.childCount !== right.childCount) {
+    return false;
+  }
+  for (let index = 0; index < left.childCount; index++) {
+    if (!sameNode(left.child(index), right.child(index))) {
+      return false;
+    }
+  }
+  return true;
+};
+
+// Positions include document structure, not just character offsets. A non-leaf node
+// uses one position for each opening/closing boundary, plus the size of its content.
+// Example: paragraph('Hi') at pos 0 has nodeSize 4, outer range [0, 4),
+// and text content [1, 3). All ranges here use an exclusive end position.
+
+// Keep the reason internally so a panel attribute change can survive child edits.
+// Only ordinary { from, to } ranges are returned to the chrome consumer.
+
+const collectChanges = (before, after, map, ranges) => {
+  const {
+    node,
+    pos
+  } = after;
+  if (before && sameNode(before.node, node)) {
+    return;
+  }
+  // Text edits belong to their textblock. A node's own markup change instead
+  // owns its full content, so we stop here rather than adding child ranges too.
+  const markupChanged = !!before && node.isBlock && !sameMarkup(before.node, node);
+  if (node.isTextblock || markupChanged) {
+    if (node.content.size > 0) {
+      ranges.push({
+        from: pos,
+        to: pos + node.nodeSize,
+        markupChanged
+      });
+    }
+    return;
+  }
+  const byPosition = new Map();
+  const byId = new Map();
+  const oldChildren = [];
+  before === null || before === void 0 ? void 0 : before.node.forEach((child, offset) => {
+    // forEach offsets start inside the parent. Skip its opening boundary (+1)
+    // to convert this child offset into an absolute document position.
+    const previous = {
+      node: child,
+      pos: before.pos + 1 + offset
+    };
+    oldChildren.push(previous);
+    // This 1 is a mapping bias, not an added offset: follow the right side
+    // of an insertion at the child's start, keeping the original child after it.
+    const mapped = map.mapResult(previous.pos, 1);
+    if (!mapped.deleted) {
+      byPosition.set(mapped.pos, previous);
+    }
+    const id = child.attrs.localId;
+    if (typeof id === 'string' && id) {
+      // Duplicate IDs cannot identify a unique old child.
+      byId.set(id, byId.has(id) ? null : previous);
+    }
+  });
+  const nextChildren = [];
+  node.forEach((child, offset) => nextChildren.push({
+    node: child,
+    pos: pos + 1 + offset
+  }));
+  // Narrow edits usually preserve mapped positions. Whole-container replacements
+  // may erase those positions, so stable child IDs provide a second way to match.
+  const preferred = nextChildren.map(next => {
+    var _ref, _byPosition$get;
+    return (_ref = (_byPosition$get = byPosition.get(next.pos)) !== null && _byPosition$get !== void 0 ? _byPosition$get : byId.get(next.node.attrs.localId)) !== null && _ref !== void 0 ? _ref : undefined;
+  });
+  const claims = new Map();
+  for (const match of preferred) {
+    if (match) {
+      var _claims$get;
+      claims.set(match, ((_claims$get = claims.get(match)) !== null && _claims$get !== void 0 ? _claims$get : 0) + 1);
+    }
+  }
+  nextChildren.forEach((next, index) => {
+    const match = preferred[index];
+    // Same-index fallback supports replacements that regenerate IDs but keep
+    // the child structure. Different child counts make that correspondence unsafe.
+    const aligned = oldChildren.length === node.childCount ? oldChildren[index] : undefined;
+    // Reserve every position/ID match before fallback, including later siblings.
+    // Reusing one old sibling can otherwise disguise an equal-text insertion.
+    const previous = match && claims.get(match) === 1 ? match : aligned && !claims.has(aligned) ? aligned : undefined;
+    collectChanges(previous, next, map, ranges);
+  });
+};
+const findPreservedNode = (doc, previous, markupChanged, indexes) => {
+  const id = previous.attrs.localId;
+  if (typeof id !== 'string' || !id) {
+    return;
+  }
+  let byId = indexes.get(doc);
+  if (!byId) {
+    // Build only when mapping loses a candidate, then reuse for every range
+    // visiting this immutable snapshot. Ordinary mapped edits need no scan.
+    const nodeIndex = new Map();
+    doc.descendants((node, pos) => {
+      const localId = node.attrs.localId;
+      if (typeof localId === 'string' && localId) {
+        // Keep duplicates ambiguous, including IDs outside the changed subtree.
+        nodeIndex.set(localId, nodeIndex.has(localId) ? null : {
+          node,
+          pos
+        });
+      }
+    });
+    indexes.set(doc, nodeIndex);
+    byId = nodeIndex;
+  }
+  const match = byId.get(id);
+  // Attribute/mark activity belongs to the node even when its children are edited.
+  // Content-only activity still requires the entire candidate to survive unchanged.
+  const isPreserved = markupChanged ? sameMarkup : sameNode;
+  return match && isPreserved(previous, match.node) ? match : undefined;
+};
+const mapToFinalBlocks = (tr, index, range, indexes) => {
+  var _tr$docs;
+  let {
+    from,
+    to
+  } = range;
+  // Track inner content separately from outer node bounds: +1 skips the opening
+  // boundary and -1 excludes the closing boundary (see paragraph example above).
+  let contentFrom = from + 1;
+  let contentTo = to - 1;
+  // docs[i] is the document BEFORE step i, so docs[i + 1] is its result.
+  // The last step has no next snapshot; tr.doc is its result instead.
+  let node = ((_tr$docs = tr.docs[index + 1]) !== null && _tr$docs !== void 0 ? _tr$docs : tr.doc).nodeAt(from);
+  if (!node) {
+    return [];
+  }
+  // Later non-AI steps also shift/delete existing activity, even though they
+  // cannot create new activity themselves. Process every intermediate document.
+  for (let next = index + 1; next < tr.steps.length; next++) {
+    var _tr$docs2;
+    const map = tr.mapping.maps[next];
+    const after = (_tr$docs2 = tr.docs[next + 1]) !== null && _tr$docs2 !== void 0 ? _tr$docs2 : tr.doc;
+    // Mapping biases +1 (right) and -1 (left) keep boundary insertions outside
+    // the tracked content. These arguments do not add/subtract document positions.
+    const start = map.mapResult(contentFrom, 1);
+    const end = map.mapResult(contentTo, -1);
+    if (start.deleted && end.deleted || end.pos <= start.pos) {
+      // A cumulative replacement can preserve the candidate content or owned markup.
+      // Check every intermediate doc so deletion then reinsertion never resurrects it.
+      const preserved = findPreservedNode(after, node, range.markupChanged, indexes);
+      if (!preserved) {
+        return [];
+      }
+      from = preserved.pos;
+      to = from + preserved.node.nodeSize;
+      contentFrom = from + 1;
+      contentTo = to - 1;
+      node = preserved.node;
+    } else {
+      // Apply the same inward biases to the outer node bounds.
+      from = map.map(from, 1);
+      to = map.map(to, -1);
+      contentFrom = start.pos;
+      contentTo = end.pos;
+      const current = after.nodeAt(from);
+      if (current && current.nodeSize === to - from) {
+        node = current;
+      }
+    }
+  }
+  if (from < 0 || to > tr.doc.content.size || contentTo <= contentFrom) {
+    return [];
+  }
+  const finalNode = tr.doc.nodeAt(from);
+  if (finalNode !== null && finalNode !== void 0 && finalNode.isBlock && finalNode.nodeSize === to - from) {
+    return [{
+      from,
+      to
+    }];
+  }
+  // Joins/splits can leave mapped boundaries inside the final textblock.
+  const blocks = [];
+  tr.doc.nodesBetween(contentFrom, contentTo, (child, pos) => {
+    if (child.isTextblock) {
+      blocks.push({
+        from: pos,
+        to: pos + child.nodeSize
+      });
+      return false;
+    }
+  });
+  return blocks;
+};
+
+/**
+ * Returns whole content-block ranges for selected applied steps, in tr.doc coordinates.
+ * Callers select actual AI writes (excluding restores, acknowledgments and preparation)
+ * and own experiment/lifecycle decisions. This helper does not dispatch or render.
+ *
+ * Comparing each step's snapshots also handles attribute/mark steps with empty maps.
+ * Shared unchanged subtrees are skipped by reference. Only localId changes are ignored;
+ * meaningful attributes and marks retain the affected node's full content scope.
+ */
+export function getAgentEditChangedRanges(tr, includedStepIndexes) {
+  // Positions belong to each intermediate document, not just tr.doc. Keep the
+  // lazy indexes local to this call so deletion/reinsertion checks stay intact
+  // and no cache is retained between transactions or streaming chunks.
+  const indexes = new WeakMap();
+  const ranges = [];
+  for (const index of new Set(includedStepIndexes)) {
+    var _tr$docs3;
+    if (!Number.isInteger(index) || index < 0 || index >= tr.steps.length) {
+      continue;
+    }
+    const changed = [];
+    // The root document has no opening boundary. Using -1 makes the recursive
+    // parent.pos + 1 + offset formula place its first child at position 0.
+    collectChanges({
+      node: tr.docs[index],
+      pos: -1
+    }, {
+      node: (_tr$docs3 = tr.docs[index + 1]) !== null && _tr$docs3 !== void 0 ? _tr$docs3 : tr.doc,
+      pos: -1
+    }, tr.steps[index].getMap(), changed);
+    for (const range of changed) {
+      ranges.push(...mapToFinalBlocks(tr, index, range, indexes));
+    }
+  }
+
+  // Return only the surviving final-document ranges, never intermediate step states.
+  // Sort outer ranges before their children, then discard duplicates/contained ranges.
+  // Separate ranges stay separate; this must not highlight the untouched gaps.
+  const unique = [];
+  for (const range of ranges.sort((left, right) => left.from - right.from || right.to - left.to)) {
+    const previous = unique[unique.length - 1];
+    if (!previous || range.to > previous.to) {
+      unique.push(range);
+    }
+  }
+  return unique;
+}

package/dist/es2019/monitoring/error.js

@@ -13,7 +13,7 @@ const NETWORK_FAILURE_REGEX = /^network failure/i;
 const RESIZE_OBSERVER_LOOP_REGEX = /ResizeObserver loop completed with undelivered notifications/;
 const SENTRY_DSN = 'https://0b10c8e02fb44d8796c047b102c9bee8@o55978.ingest.sentry.io/4505129224110080';
 const packageName = 'editor-common'; // Sentry doesn't accept '/' in its releases https://docs.sentry.io/platforms/javascript/configuration/releases/
-const packageVersion = "122.4.0";
+const packageVersion = "122.5.0";
 const sanitiseSentryEvents = (data, _hint) => {
   // Remove URL as it has UGC
   // Ignored via go/ees007

package/dist/es2019/transforms/getFormattedNode.js

@@ -1,5 +1,4 @@
 import { findParentNodeOfType, findSelectedNodeOfType } from '@atlaskit/editor-prosemirror/utils';
-import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 export const getFormattedNode = tr => {
   const {
     selection
@@ -7,10 +6,7 @@ export const getFormattedNode = tr => {
   const {
     nodes
   } = tr.doc.type.schema;
-
-  // gating behind platform_editor_small_font_size to support task lists with font size applied,
-  // but keep this solution general
-  const isBlockTaskItemEnabled = !!nodes.blockTaskItem && expValEquals('platform_editor_small_font_size', 'isEnabled', true);
+  const isBlockTaskItemEnabled = !!nodes.blockTaskItem;
 
   // Find the node to format from the current selection
   let nodeToFormat;

package/dist/es2019/transforms/list-transforms.js

@@ -1,5 +1,4 @@
 import { Fragment } from '@atlaskit/editor-prosemirror/model';
-import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { convertBlockToInlineContent } from './convertBlockToInlineContent';
 import { createBlockTaskItem } from './createBlockTaskItem';
 import { isBulletOrOrderedList } from './isBulletOrOrderedList';
@@ -34,10 +33,7 @@ export const transformListRecursively = (props, onhandleUnsupportedContent) => {
     paragraph,
     blockTaskItem
   } = schema.nodes;
-
-  // gating behind platform_editor_small_font_size to support task lists with font size applied,
-  // but keep this solution general
-  const isBlockTaskEnabled = !!blockTaskItem && expValEquals('platform_editor_small_font_size', 'isEnabled', true);
+  const isBlockTaskEnabled = !!blockTaskItem;
 
   /**
    * Extracts paragraph children from a blockTaskItem, preserving their marks.
@@ -204,9 +200,7 @@ export const transformToTaskList = (tr, range, targetNodeType, targetAttrs, node
       paragraph,
       blockTaskItem
     } = nodes;
-    // gating behind platform_editor_small_font_size to support task lists with font size applied,
-    // but keep this solution general
-    const isBlockTaskItemEnabled = !!blockTaskItem && expValEquals('platform_editor_small_font_size', 'isEnabled', true);
+    const isBlockTaskItemEnabled = !!blockTaskItem;
     const listItems = [];
 
     // Process each block in the range

package/dist/es2019/transforms/transformTaskListToBlockNodes.js

@@ -1,6 +1,5 @@
 import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
 import { findChildrenByType } from '@atlaskit/editor-prosemirror/utils';
-import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 export const transformTaskListToBlockNodes = context => {
   const {
     tr,
@@ -16,10 +15,7 @@ export const transformTaskListToBlockNodes = context => {
   const {
     blockTaskItem
   } = schema.nodes;
-
-  // gating behind platform_editor_small_font_size to support task lists with font size applied,
-  // but keep this solution general
-  const isBlockTaskItemEnabled = !!blockTaskItem && expValEquals('platform_editor_small_font_size', 'isEnabled', true);
+  const isBlockTaskItemEnabled = !!blockTaskItem;
   if (isBlockTaskItemEnabled) {
     const blockTaskItemsResult = findChildrenByType(sourceNode, blockTaskItem);
     if (blockTaskItemsResult.length > 0 && targetNodeType === schema.nodes.paragraph) {

package/dist/es2019/ui/DropList/index.js

@@ -14,7 +14,7 @@ import withAnalyticsEvents from '@atlaskit/analytics-next/withAnalyticsEvents';
 import { fg } from '@atlaskit/platform-feature-flags/fg';
 import Layer from '../Layer';
 const packageName = "@atlaskit/editor-common";
-const packageVersion = "122.4.0";
+const packageVersion = "122.5.0";
 const halfFocusRing = 1;
 const dropOffset = '0, 8';
 const fadeIn = keyframes({

package/dist/esm/collab/agent-edit-changed-ranges.js

@@ -0,0 +1,297 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+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; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import isEqual from 'lodash/isEqual';
+// localId is identity metadata: regenerating it alone should not create activity.
+var sameAttrs = function sameAttrs(left, right) {
+  var keys = Object.keys(left).filter(function (key) {
+    return key !== 'localId';
+  });
+  return keys.length === Object.keys(right).filter(function (key) {
+    return key !== 'localId';
+  }).length && keys.every(function (key) {
+    return isEqual(left[key], right[key]);
+  });
+};
+
+// Compare the node's own type, attributes and marks, without comparing its children.
+var sameMarkup = function sameMarkup(left, right) {
+  return left.type === right.type && sameAttrs(left.attrs, right.attrs) && left.marks.length === right.marks.length && left.marks.every(function (mark, index) {
+    return mark.type === right.marks[index].type && sameAttrs(mark.attrs, right.marks[index].attrs);
+  });
+};
+var _sameNode = function sameNode(left, right) {
+  if (left === right) {
+    return true;
+  }
+  if (!sameMarkup(left, right) || left.text !== right.text || left.childCount !== right.childCount) {
+    return false;
+  }
+  for (var index = 0; index < left.childCount; index++) {
+    if (!_sameNode(left.child(index), right.child(index))) {
+      return false;
+    }
+  }
+  return true;
+};
+
+// Positions include document structure, not just character offsets. A non-leaf node
+// uses one position for each opening/closing boundary, plus the size of its content.
+// Example: paragraph('Hi') at pos 0 has nodeSize 4, outer range [0, 4),
+// and text content [1, 3). All ranges here use an exclusive end position.
+
+// Keep the reason internally so a panel attribute change can survive child edits.
+// Only ordinary { from, to } ranges are returned to the chrome consumer.
+
+var _collectChanges = function collectChanges(before, after, map, ranges) {
+  var node = after.node,
+    pos = after.pos;
+  if (before && _sameNode(before.node, node)) {
+    return;
+  }
+  // Text edits belong to their textblock. A node's own markup change instead
+  // owns its full content, so we stop here rather than adding child ranges too.
+  var markupChanged = !!before && node.isBlock && !sameMarkup(before.node, node);
+  if (node.isTextblock || markupChanged) {
+    if (node.content.size > 0) {
+      ranges.push({
+        from: pos,
+        to: pos + node.nodeSize,
+        markupChanged: markupChanged
+      });
+    }
+    return;
+  }
+  var byPosition = new Map();
+  var byId = new Map();
+  var oldChildren = [];
+  before === null || before === void 0 || before.node.forEach(function (child, offset) {
+    // forEach offsets start inside the parent. Skip its opening boundary (+1)
+    // to convert this child offset into an absolute document position.
+    var previous = {
+      node: child,
+      pos: before.pos + 1 + offset
+    };
+    oldChildren.push(previous);
+    // This 1 is a mapping bias, not an added offset: follow the right side
+    // of an insertion at the child's start, keeping the original child after it.
+    var mapped = map.mapResult(previous.pos, 1);
+    if (!mapped.deleted) {
+      byPosition.set(mapped.pos, previous);
+    }
+    var id = child.attrs.localId;
+    if (typeof id === 'string' && id) {
+      // Duplicate IDs cannot identify a unique old child.
+      byId.set(id, byId.has(id) ? null : previous);
+    }
+  });
+  var nextChildren = [];
+  node.forEach(function (child, offset) {
+    return nextChildren.push({
+      node: child,
+      pos: pos + 1 + offset
+    });
+  });
+  // Narrow edits usually preserve mapped positions. Whole-container replacements
+  // may erase those positions, so stable child IDs provide a second way to match.
+  var preferred = nextChildren.map(function (next) {
+    var _ref, _byPosition$get;
+    return (_ref = (_byPosition$get = byPosition.get(next.pos)) !== null && _byPosition$get !== void 0 ? _byPosition$get : byId.get(next.node.attrs.localId)) !== null && _ref !== void 0 ? _ref : undefined;
+  });
+  var claims = new Map();
+  var _iterator = _createForOfIteratorHelper(preferred),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var match = _step.value;
+      if (match) {
+        var _claims$get;
+        claims.set(match, ((_claims$get = claims.get(match)) !== null && _claims$get !== void 0 ? _claims$get : 0) + 1);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  nextChildren.forEach(function (next, index) {
+    var match = preferred[index];
+    // Same-index fallback supports replacements that regenerate IDs but keep
+    // the child structure. Different child counts make that correspondence unsafe.
+    var aligned = oldChildren.length === node.childCount ? oldChildren[index] : undefined;
+    // Reserve every position/ID match before fallback, including later siblings.
+    // Reusing one old sibling can otherwise disguise an equal-text insertion.
+    var previous = match && claims.get(match) === 1 ? match : aligned && !claims.has(aligned) ? aligned : undefined;
+    _collectChanges(previous, next, map, ranges);
+  });
+};
+var findPreservedNode = function findPreservedNode(doc, previous, markupChanged, indexes) {
+  var id = previous.attrs.localId;
+  if (typeof id !== 'string' || !id) {
+    return;
+  }
+  var byId = indexes.get(doc);
+  if (!byId) {
+    // Build only when mapping loses a candidate, then reuse for every range
+    // visiting this immutable snapshot. Ordinary mapped edits need no scan.
+    var nodeIndex = new Map();
+    doc.descendants(function (node, pos) {
+      var localId = node.attrs.localId;
+      if (typeof localId === 'string' && localId) {
+        // Keep duplicates ambiguous, including IDs outside the changed subtree.
+        nodeIndex.set(localId, nodeIndex.has(localId) ? null : {
+          node: node,
+          pos: pos
+        });
+      }
+    });
+    indexes.set(doc, nodeIndex);
+    byId = nodeIndex;
+  }
+  var match = byId.get(id);
+  // Attribute/mark activity belongs to the node even when its children are edited.
+  // Content-only activity still requires the entire candidate to survive unchanged.
+  var isPreserved = markupChanged ? sameMarkup : _sameNode;
+  return match && isPreserved(previous, match.node) ? match : undefined;
+};
+var mapToFinalBlocks = function mapToFinalBlocks(tr, index, range, indexes) {
+  var _tr$docs;
+  var from = range.from,
+    to = range.to;
+  // Track inner content separately from outer node bounds: +1 skips the opening
+  // boundary and -1 excludes the closing boundary (see paragraph example above).
+  var contentFrom = from + 1;
+  var contentTo = to - 1;
+  // docs[i] is the document BEFORE step i, so docs[i + 1] is its result.
+  // The last step has no next snapshot; tr.doc is its result instead.
+  var node = ((_tr$docs = tr.docs[index + 1]) !== null && _tr$docs !== void 0 ? _tr$docs : tr.doc).nodeAt(from);
+  if (!node) {
+    return [];
+  }
+  // Later non-AI steps also shift/delete existing activity, even though they
+  // cannot create new activity themselves. Process every intermediate document.
+  for (var next = index + 1; next < tr.steps.length; next++) {
+    var _tr$docs2;
+    var map = tr.mapping.maps[next];
+    var after = (_tr$docs2 = tr.docs[next + 1]) !== null && _tr$docs2 !== void 0 ? _tr$docs2 : tr.doc;
+    // Mapping biases +1 (right) and -1 (left) keep boundary insertions outside
+    // the tracked content. These arguments do not add/subtract document positions.
+    var start = map.mapResult(contentFrom, 1);
+    var end = map.mapResult(contentTo, -1);
+    if (start.deleted && end.deleted || end.pos <= start.pos) {
+      // A cumulative replacement can preserve the candidate content or owned markup.
+      // Check every intermediate doc so deletion then reinsertion never resurrects it.
+      var preserved = findPreservedNode(after, node, range.markupChanged, indexes);
+      if (!preserved) {
+        return [];
+      }
+      from = preserved.pos;
+      to = from + preserved.node.nodeSize;
+      contentFrom = from + 1;
+      contentTo = to - 1;
+      node = preserved.node;
+    } else {
+      // Apply the same inward biases to the outer node bounds.
+      from = map.map(from, 1);
+      to = map.map(to, -1);
+      contentFrom = start.pos;
+      contentTo = end.pos;
+      var current = after.nodeAt(from);
+      if (current && current.nodeSize === to - from) {
+        node = current;
+      }
+    }
+  }
+  if (from < 0 || to > tr.doc.content.size || contentTo <= contentFrom) {
+    return [];
+  }
+  var finalNode = tr.doc.nodeAt(from);
+  if (finalNode !== null && finalNode !== void 0 && finalNode.isBlock && finalNode.nodeSize === to - from) {
+    return [{
+      from: from,
+      to: to
+    }];
+  }
+  // Joins/splits can leave mapped boundaries inside the final textblock.
+  var blocks = [];
+  tr.doc.nodesBetween(contentFrom, contentTo, function (child, pos) {
+    if (child.isTextblock) {
+      blocks.push({
+        from: pos,
+        to: pos + child.nodeSize
+      });
+      return false;
+    }
+  });
+  return blocks;
+};
+
+/**
+ * Returns whole content-block ranges for selected applied steps, in tr.doc coordinates.
+ * Callers select actual AI writes (excluding restores, acknowledgments and preparation)
+ * and own experiment/lifecycle decisions. This helper does not dispatch or render.
+ *
+ * Comparing each step's snapshots also handles attribute/mark steps with empty maps.
+ * Shared unchanged subtrees are skipped by reference. Only localId changes are ignored;
+ * meaningful attributes and marks retain the affected node's full content scope.
+ */
+export function getAgentEditChangedRanges(tr, includedStepIndexes) {
+  // Positions belong to each intermediate document, not just tr.doc. Keep the
+  // lazy indexes local to this call so deletion/reinsertion checks stay intact
+  // and no cache is retained between transactions or streaming chunks.
+  var indexes = new WeakMap();
+  var ranges = [];
+  var _iterator2 = _createForOfIteratorHelper(new Set(includedStepIndexes)),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _tr$docs3;
+      var index = _step2.value;
+      if (!Number.isInteger(index) || index < 0 || index >= tr.steps.length) {
+        continue;
+      }
+      var changed = [];
+      // The root document has no opening boundary. Using -1 makes the recursive
+      // parent.pos + 1 + offset formula place its first child at position 0.
+      _collectChanges({
+        node: tr.docs[index],
+        pos: -1
+      }, {
+        node: (_tr$docs3 = tr.docs[index + 1]) !== null && _tr$docs3 !== void 0 ? _tr$docs3 : tr.doc,
+        pos: -1
+      }, tr.steps[index].getMap(), changed);
+      for (var _i = 0, _changed = changed; _i < _changed.length; _i++) {
+        var range = _changed[_i];
+        ranges.push.apply(ranges, _toConsumableArray(mapToFinalBlocks(tr, index, range, indexes)));
+      }
+    }
+
+    // Return only the surviving final-document ranges, never intermediate step states.
+    // Sort outer ranges before their children, then discard duplicates/contained ranges.
+    // Separate ranges stay separate; this must not highlight the untouched gaps.
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  var unique = [];
+  var _iterator3 = _createForOfIteratorHelper(ranges.sort(function (left, right) {
+      return left.from - right.from || right.to - left.to;
+    })),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var _range = _step3.value;
+      var previous = unique[unique.length - 1];
+      if (!previous || _range.to > previous.to) {
+        unique.push(_range);
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  return unique;
+}

package/dist/esm/monitoring/error.js

@@ -19,7 +19,7 @@ var NETWORK_FAILURE_REGEX = /^network failure/i;
 var RESIZE_OBSERVER_LOOP_REGEX = /ResizeObserver loop completed with undelivered notifications/;
 var SENTRY_DSN = 'https://0b10c8e02fb44d8796c047b102c9bee8@o55978.ingest.sentry.io/4505129224110080';
 var packageName = 'editor-common'; // Sentry doesn't accept '/' in its releases https://docs.sentry.io/platforms/javascript/configuration/releases/
-var packageVersion = "122.4.0";
+var packageVersion = "122.5.0";
 var sanitiseSentryEvents = function sanitiseSentryEvents(data, _hint) {
   // Remove URL as it has UGC
   // Ignored via go/ees007

package/dist/esm/transforms/getFormattedNode.js

@@ -1,12 +1,8 @@
 import { findParentNodeOfType, findSelectedNodeOfType } from '@atlaskit/editor-prosemirror/utils';
-import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 export var getFormattedNode = function getFormattedNode(tr) {
   var selection = tr.selection;
   var nodes = tr.doc.type.schema.nodes;
-
-  // gating behind platform_editor_small_font_size to support task lists with font size applied,
-  // but keep this solution general
-  var isBlockTaskItemEnabled = !!nodes.blockTaskItem && expValEquals('platform_editor_small_font_size', 'isEnabled', true);
+  var isBlockTaskItemEnabled = !!nodes.blockTaskItem;
 
   // Find the node to format from the current selection
   var nodeToFormat;

package/dist/esm/transforms/list-transforms.js

@@ -3,7 +3,6 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 import { Fragment } from '@atlaskit/editor-prosemirror/model';
-import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { convertBlockToInlineContent } from './convertBlockToInlineContent';
 import { createBlockTaskItem } from './createBlockTaskItem';
 import { isBulletOrOrderedList } from './isBulletOrOrderedList';
@@ -35,10 +34,7 @@ var _transformListRecursively = function transformListRecursively(props, onhandl
     taskItem = _schema$nodes.taskItem,
     paragraph = _schema$nodes.paragraph,
     blockTaskItem = _schema$nodes.blockTaskItem;
-
-  // gating behind platform_editor_small_font_size to support task lists with font size applied,
-  // but keep this solution general
-  var isBlockTaskEnabled = !!blockTaskItem && expValEquals('platform_editor_small_font_size', 'isEnabled', true);
+  var isBlockTaskEnabled = !!blockTaskItem;
 
   /**
    * Extracts paragraph children from a blockTaskItem, preserving their marks.
@@ -199,9 +195,7 @@ export var transformToTaskList = function transformToTaskList(tr, range, targetN
     var taskItem = nodes.taskItem,
       paragraph = nodes.paragraph,
       blockTaskItem = nodes.blockTaskItem;
-    // gating behind platform_editor_small_font_size to support task lists with font size applied,
-    // but keep this solution general
-    var isBlockTaskItemEnabled = !!blockTaskItem && expValEquals('platform_editor_small_font_size', 'isEnabled', true);
+    var isBlockTaskItemEnabled = !!blockTaskItem;
     var listItems = [];
 
     // Process each block in the range

package/dist/esm/transforms/transformTaskListToBlockNodes.js

@@ -3,7 +3,6 @@ function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r)
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
 import { findChildrenByType } from '@atlaskit/editor-prosemirror/utils';
-import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 export var transformTaskListToBlockNodes = function transformTaskListToBlockNodes(context) {
   var tr = context.tr,
     targetNodeType = context.targetNodeType,
@@ -13,10 +12,7 @@ export var transformTaskListToBlockNodes = function transformTaskListToBlockNode
   var selection = tr.selection;
   var schema = selection.$from.doc.type.schema;
   var blockTaskItem = schema.nodes.blockTaskItem;
-
-  // gating behind platform_editor_small_font_size to support task lists with font size applied,
-  // but keep this solution general
-  var isBlockTaskItemEnabled = !!blockTaskItem && expValEquals('platform_editor_small_font_size', 'isEnabled', true);
+  var isBlockTaskItemEnabled = !!blockTaskItem;
   if (isBlockTaskItemEnabled) {
     var blockTaskItemsResult = findChildrenByType(sourceNode, blockTaskItem);
     if (blockTaskItemsResult.length > 0 && targetNodeType === schema.nodes.paragraph) {

package/dist/esm/ui/DropList/index.js

@@ -21,7 +21,7 @@ import withAnalyticsEvents from '@atlaskit/analytics-next/withAnalyticsEvents';
 import { fg } from '@atlaskit/platform-feature-flags/fg';
 import Layer from '../Layer';
 var packageName = "@atlaskit/editor-common";
-var packageVersion = "122.4.0";
+var packageVersion = "122.5.0";
 var halfFocusRing = 1;
 var dropOffset = '0, 8';
 var fadeIn = keyframes({

package/dist/types/collab/agent-edit-changed-ranges.d.ts

@@ -0,0 +1,12 @@
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { AgentEditChromeRange } from './agent-edit-chrome';
+/**
+ * Returns whole content-block ranges for selected applied steps, in tr.doc coordinates.
+ * Callers select actual AI writes (excluding restores, acknowledgments and preparation)
+ * and own experiment/lifecycle decisions. This helper does not dispatch or render.
+ *
+ * Comparing each step's snapshots also handles attribute/mark steps with empty maps.
+ * Shared unchanged subtrees are skipped by reference. Only localId changes are ignored;
+ * meaningful attributes and marks retain the affected node's full content scope.
+ */
+export declare function getAgentEditChangedRanges(tr: Transaction, includedStepIndexes: readonly number[]): AgentEditChromeRange[];

package/dist/types/provider-factory/profile-card-provider.d.ts

@@ -1,4 +1,5 @@
 import type { ReactNode } from 'react';
+import type { Placement } from '@atlaskit/popper/main';
 import type { ProfileCardAction } from '@atlaskit/profilecard/types';
 import type ProfileClient from '@atlaskit/profilecard/profile-card-client';
 /**
@@ -16,8 +17,12 @@ import type ProfileClient from '@atlaskit/profilecard/profile-card-client';
 export type RenderUserMentionCard = (props: {
     children: ReactNode;
     cloudId: string;
+    /** Renders a reduced, non-interactive card with the header + manager section only */
+    isReduced?: boolean;
     /** Optional mention-local marker supplied by the renderer. */
     localId?: string;
+    /** Popper placement for the card relative to the `referenceElement`. */
+    placement?: Placement;
     /** Known identity to prefill the card with, giving its trigger a concrete accessible name. */
     prefilledProfileData?: {
         accountId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-common",
-	"version": "122.5.0",
+	"version": "122.6.0",
 	"description": "A package that contains common classes and components for editor and renderer",
 	"publishConfig": {
 		"registry": "https://registry.npmjs.org/"
@@ -84,7 +84,7 @@
 		"@atlaskit/task-decision": "^21.10.0",
 		"@atlaskit/teams-app-config": "^3.1.0",
 		"@atlaskit/textfield": "^10.2.0",
-		"@atlaskit/tmp-editor-statsig": "^193.0.0",
+		"@atlaskit/tmp-editor-statsig": "^194.0.0",
 		"@atlaskit/tokens": "^16.12.0",
 		"@atlaskit/tooltip": "^24.3.0",
 		"@atlaskit/width-detector": "^7.2.0",