@atlaskit/editor-plugin-collab-edit 15.0.7 → 15.0.8

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @atlaskit/editor-plugin-collab-edit
 
+## 15.0.8
+
+### Patch Changes
+
+- [`1d1cb3e25a787`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/1d1cb3e25a787) -
+  Fix BE-streaming Review moment data loss and chimera diffs: derive coarse review segments as
+  closed, whole top-level node slices (mapped consistently between the pre-edit and post-edit doc),
+  filter out position-neutral phantom collab touches, and fall back to a safe add-only segment when
+  a change relocates content. Behind the platform_editor_backend_review_moment_agent_types gate.
+- Updated dependencies
+
 ## 15.0.7
 
 ### Patch Changes

package/dist/cjs/pm-plugins/main/agent-review-segments.js

@@ -13,21 +13,47 @@ var REVIEW_MOMENT_AGENT_TYPES_CONFIG = exports.REVIEW_MOMENT_AGENT_TYPES_CONFIG
 
 // [CCI-17994] Post Stream Review ("Review moment") recording for BE streaming.
 //
-// Sibling to `getAgentShimmerRanges`: same idea of deriving what the agent wrote
-// from a received remote-step batch, but for a DIFFERENT consumer. The shimmer
-// only needs the NEW extent of added content (to draw a skeleton), so it drops
-// pure deletions and expands to whole blocks. The Review moment instead needs, per
-// contiguous change, BOTH the original slice (pre-edit, for undo / "compare with
-// original") and the new slice (for redo), AND it must keep deletions (a removed
-// paragraph is a reviewable change). So this derives the actual changed extents
-// and reconstructs the pre-edit slice from `tr.before`.
+// Sibling to `getAgentShimmerRanges`, but for a different consumer: the shimmer
+// only needs the NEW extent of added content, whereas the Review moment needs, per
+// contiguous change, BOTH the pre-edit slice (for undo) and the new slice (for
+// redo), and must keep deletions. The output is a neutral
+// `AgentRemoteEditReviewData`; `editor-plugin-ai` turns each segment into a coarse
+// `aiContentPositions` entry and reuses the entire FE Review moment pipeline.
 //
-// The output is a neutral `AgentRemoteEditReviewData` (contract in editor-common);
-// `editor-plugin-ai`'s session-context plugin turns each segment into a coarse
-// `aiContentPositions` entry, reusing the entire FE Review moment pipeline.
+// That pipeline requires every coarse entry to be a CLOSED, whole-node slice
+// occupying exactly `[startPos, endPos]`. If a slice is left OPEN (a partial node,
+// e.g. "…\nD") it drops the node wrapper on reconstruction — losing content on undo
+// (data-loss bug) and bleeding highlights into neighbouring nodes. So we expand
+// every change to whole-node outer boundaries and only emit self-consistent
+// entries (see the group loop below).
 
 var clampToDoc = function clampToDoc(doc, pos) {
-  return Math.min(Math.max(pos, 0), doc.content.size);
+  return Math.min(Math.max(pos, 1), doc.content.size);
+};
+var topLevelBlockIndexAt = function topLevelBlockIndexAt(doc, pos) {
+  return doc.resolve(clampToDoc(doc, pos)).index(0);
+};
+
+// Outer boundaries (before/after tokens) of the top-level node containing `pos`.
+// Slicing between these includes each node's own wrapper tokens, so the slice is
+// CLOSED (`openStart === openEnd === 0`) and preserves node type on reconstruction
+// (a `heading` stays a heading). `depth === 0` means `pos` sits between top-level
+// nodes, so it is already a node boundary.
+// Whether `pos` sits INSIDE a top-level node (depth > 0) vs exactly on a node
+// boundary (depth 0). Unlike `clampToDoc`, this clamps to `[0, size]` (allowing 0)
+// so the doc-start boundary is correctly reported as a boundary, not forced into
+// the first node. Used to tell a structural add/remove (zero-width span at a node
+// boundary) from a text-only insert/delete inside a surviving node.
+var isInsideNode = function isInsideNode(doc, pos) {
+  return doc.resolve(Math.min(Math.max(pos, 0), doc.content.size)).depth > 0;
+};
+var topLevelNodeStart = function topLevelNodeStart(doc, pos) {
+  var $pos = doc.resolve(clampToDoc(doc, pos));
+  return $pos.depth === 0 ? $pos.pos : $pos.before(1);
+};
+var topLevelNodeEnd = function topLevelNodeEnd(doc, pos) {
+  var $pos = doc.resolve(clampToDoc(doc, pos));
+  return $pos.depth === 0 ? $pos.pos : $pos.after(1);
 };
 
 // Map a position in doc_{i+1} forward through the remaining steps to final-doc
@@ -41,11 +67,31 @@ var mapToFinalDoc = function mapToFinalDoc(steps, pos, stepIndex, bias) {
   return p;
 };
 
+// Map a step's `old` coord (valid in doc_i, this step's input) back to pre-batch
+// (`tr.before`) coords by inverting the PRECEDING steps' maps in reverse. Needed to
+// recover a deletion's original span: its new extent is zero-width, so it cannot be
+// found by inverse-mapping the collapsed new point.
+var mapToBeforeDoc = function mapToBeforeDoc(steps, pos, stepIndex, bias) {
+  var p = pos;
+  for (var j = stepIndex - 1; j >= 0; j--) {
+    p = steps[j].getMap().invert().map(p, bias);
+  }
+  return p;
+};
+
+/**
+ * A change region tracked in BOTH coordinate spaces: `[from, to]` in the final doc
+ * (`tr.doc`) and `[origFrom, origTo]` in the pre-batch doc (`tr.before`). Carrying
+ * the original span explicitly lets a deletion (zero-width final extent) still
+ * recover its removed content.
+ */
+
 /**
  * Derive per-change Review moment segments from an agent-authored remote-step
- * batch. Returns `null` when there is nothing to record (no agent steps, or a
- * rebase invalidated our index math, or derivation threw) so the caller can no-op
- * safely — this must never throw into the shared remote-step handler.
+ * batch. Returns `null` when there is nothing to record (no agent steps, agentType
+ * not allowlisted, a rebase invalidated our index math, or derivation threw) so the
+ * caller can no-op safely — this must never throw into the shared remote-step
+ * handler.
  *
  * @param json  the raw received step JSON (carries `agentType` / `agentId` / `userId`)
  * @param steps the parsed PM steps (index-aligned with `json`)
@@ -96,23 +142,11 @@ var getAgentEditSegments = exports.getAgentEditSegments = function getAgentEditS
     }
   }
   try {
-    // Compute one segment per step-level StepMap range. Each agent step's changed
-    // extent is taken from its StepMap (the canonical, step-type-agnostic source).
-    // Unlike the shimmer we KEEP zero-width new extents — a pure deletion has
-    // `newEnd === newStart` but is a reviewable `remove`.
-    //
-    // We derive the originalSlice/newSlice PER RANGE (per step) rather than
-    // grouping ranges first and then inverting over a merged range. Grouping
-    // before slicing corrupts the invert-mapping: when multiple discrete
-    // operations (e.g. two deleteNode + one insertNodeAfter) are merged into one
-    // range, mapping that merged range back through the inverted mapping produces
-    // a chimera — a blend of old and new text that never existed in the document.
-    //
-    // The downstream PSR pipeline (mergeOverlappingSegments +
-    // calculateTopLevelNodeSegments) already handles overlapping/adjacent coarse
-    // entries correctly, so grouping here is unnecessary.
-
-    var segments = [];
+    // Each agent step's changed extent in FINAL-doc coords, taken from its StepMap
+    // (the canonical, step-type-agnostic source). Unlike the shimmer we KEEP
+    // zero-width new extents — a pure deletion has `newEnd === newStart` but is a
+    // reviewable `remove`.
+    var ranges = [];
     json.forEach(function (rawStep, index) {
       if (typeof (rawStep === null || rawStep === void 0 ? void 0 : rawStep.agentType) !== 'string') {
         return;
@@ -123,55 +157,121 @@ var getAgentEditSegments = exports.getAgentEditSegments = function getAgentEditS
         return;
       }
       pmStep.getMap().forEach(function (oldStart, oldEnd, newStart, newEnd) {
-        try {
-          // NEW-doc coordinates: map this step's newStart/newEnd forward
-          // through all subsequent steps to get final-doc positions.
-          var finalFrom = mapToFinalDoc(steps, newStart, index, -1);
-          var finalTo = mapToFinalDoc(steps, newEnd, index, 1);
-          var newFrom = clampToDoc(tr.doc, Math.min(finalFrom, finalTo));
-          var newTo = clampToDoc(tr.doc, Math.max(finalFrom, finalTo));
-
-          // ORIGINAL-doc coordinates: map this step's oldStart/oldEnd
-          // BACKWARD through all preceding steps to get pre-batch
-          // (`tr.before`) positions. Each preceding step's StepMap tells
-          // us how positions shifted; we invert that shift by mapping
-          // through the inverted StepMap.
-          //
-          // This is the key difference from using `tr.mapping.invert()`
-          // which inverts ALL steps at once — that produces chimera text
-          // when multiple discrete operations (delete + delete + insert)
-          // interact in the same region. Per-step backward mapping keeps
-          // each operation's original range isolated.
-          var origStart = oldStart;
-          var origEnd = oldEnd;
-          for (var j = index - 1; j >= 0; j--) {
-            var prevMap = steps[j].getMap().invert();
-            origStart = prevMap.map(origStart, -1);
-            origEnd = prevMap.map(origEnd, 1);
-          }
-          var origFrom = clampToDoc(tr.before, Math.min(origStart, origEnd));
-          var origTo = clampToDoc(tr.before, Math.max(origStart, origEnd));
-          var originalSlice = tr.before.slice(origFrom, origTo);
-          var newSlice = tr.doc.slice(newFrom, newTo);
-          var originalEmpty = originalSlice.content.size === 0;
-          var newEmpty = newSlice.content.size === 0;
-          // A truly empty-to-empty region is not a change — skip it.
-          if (originalEmpty && newEmpty) {
-            return;
+        var mappedFrom = mapToFinalDoc(steps, newStart, index, -1);
+        var mappedTo = mapToFinalDoc(steps, newEnd, index, 1);
+        // The same change in pre-batch coords, so a deletion (zero-width new
+        // extent) still carries its original span.
+        var mappedOrigFrom = mapToBeforeDoc(steps, oldStart, index, -1);
+        var mappedOrigTo = mapToBeforeDoc(steps, oldEnd, index, 1);
+        // Skip position-neutral phantom touches: the collab apply stamps same-size
+        // re-writes on unrelated nodes (e.g. `localId` on panels). Drop them only
+        // when byte-identical, so a real same-size replacement is preserved.
+        if (oldEnd - oldStart === newEnd - newStart) {
+          try {
+            var before = tr.before.slice(oldStart, oldEnd);
+            var after = tr.doc.slice(mappedFrom, mappedTo);
+            if (before.content.eq(after.content)) {
+              return;
+            }
+          } catch (_unused) {
+            // Comparison unsafe: keep the range; whole-block expansion + the
+            // later identical-content skip still guard against phantoms.
           }
-          var kind = originalEmpty ? 'add' : newEmpty ? 'remove' : 'update';
-          segments.push({
-            startPos: newFrom,
-            endPos: newTo,
-            originalSlice: originalSlice,
-            newSlice: newSlice,
-            kind: kind
-          });
-        } catch (_unused) {
-          // One bad range must not drop the others.
         }
+        ranges.push({
+          from: mappedFrom,
+          to: mappedTo,
+          origFrom: mappedOrigFrom,
+          origTo: mappedOrigTo
+        });
       });
     });
+    if (!ranges.length) {
+      return null;
+    }
+
+    // Coalesce fragments in the same/adjacent top-level block into one region (a
+    // single agent edit arrives as many small replace fragments); an untouched block
+    // between them splits the run so far-apart edits stay separate. Each region
+    // becomes one coarse segment; the AI plugin refines it further.
+    var sorted = [].concat(ranges).sort(function (a, b) {
+      return a.from - b.from || a.to - b.to;
+    });
+    var groups = [];
+    sorted.forEach(function (range) {
+      var block = topLevelBlockIndexAt(tr.doc, range.from);
+      var current = groups[groups.length - 1];
+      // Coalesce changes in the same or directly-adjacent top-level block (index n /
+      // n+1) into one region, exactly like the shimmer — a single agent edit arrives
+      // as many small fragments. A genuinely untouched block in between (index gap
+      // > 1) splits the run, keeping far-apart edits separate. The original span is
+      // unioned in parallel so a deletion's removed content is preserved.
+      if (current && block <= current.maxBlock + 1) {
+        current.to = Math.max(current.to, range.to);
+        current.maxBlock = Math.max(current.maxBlock, block);
+        current.origFrom = Math.min(current.origFrom, range.origFrom);
+        current.origTo = Math.max(current.origTo, range.origTo);
+      } else {
+        groups.push({
+          from: range.from,
+          to: range.to,
+          maxBlock: block,
+          origFrom: range.origFrom,
+          origTo: range.origTo
+        });
+      }
+    });
+    var segments = [];
+    groups.forEach(function (group) {
+      try {
+        // Expand the NEW extent to whole-node outer boundaries → a CLOSED slice.
+        // A zero-width new extent at a top-level node boundary is a structural
+        // deletion: leave it empty (do NOT whole-node expand, or it would grab the
+        // unchanged neighbour node that now sits at that point and be discarded as an
+        // identical phantom). A zero-width new extent INSIDE a node is a text-only
+        // deletion from a surviving node, so expand to the whole node (an `update`).
+        var newIsStructuralRemove = group.from === group.to && !isInsideNode(tr.doc, group.from);
+        var newFrom = topLevelNodeStart(tr.doc, Math.min(group.from, group.to));
+        var newTo = newIsStructuralRemove ? newFrom : topLevelNodeEnd(tr.doc, Math.max(group.from, group.to));
+        var newSlice = tr.doc.slice(newFrom, newTo);
+
+        // Build the ORIGINAL slice from the carried pre-batch span, expanded to whole
+        // nodes → a CLOSED slice. Using the carried `origFrom/origTo` (from the
+        // StepMap `old` coords) rather than inverse-mapping the new bounds is what
+        // lets a deletion recover its removed content.
+        //
+        // A zero-width original span is only a true structural ADD when it sits at a
+        // top-level node boundary (inserting a whole new node). A zero-width span
+        // INSIDE a node is a text insertion into that node, so expand to the whole
+        // node (an `update`) — matching how an in-place edit reviews.
+        var origIsStructuralAdd = group.origFrom === group.origTo && !isInsideNode(tr.before, group.origFrom);
+        var origFrom = topLevelNodeStart(tr.before, Math.min(group.origFrom, group.origTo));
+        var origTo = origIsStructuralAdd ? origFrom : topLevelNodeEnd(tr.before, Math.max(group.origFrom, group.origTo));
+        var originalSlice = tr.before.slice(origFrom, origTo);
+        var originalEmpty = originalSlice.content.size === 0;
+        var newEmpty = newSlice.content.size === 0;
+        // A truly empty-to-empty region is not a change — skip it.
+        if (originalEmpty && newEmpty) {
+          return;
+        }
+        // Skip phantom artifacts: a same-size StepMap "touch" at an unrelated node
+        // (e.g. a `localId` stamp on a panel during collab apply) expands to a
+        // segment whose original and new content are identical — not a real change.
+        if (originalSlice.content.eq(newSlice.content)) {
+          return;
+        }
+        var kind = originalEmpty ? 'add' : newEmpty ? 'remove' : 'update';
+        segments.push({
+          startPos: newFrom,
+          endPos: newTo,
+          originalSlice: originalSlice,
+          newSlice: newSlice,
+          kind: kind
+        });
+      } catch (_unused2) {
+        // One bad group must not drop the others.
+      }
+    });
     if (!segments.length) {
       return null;
     }
@@ -182,7 +282,7 @@ var getAgentEditSegments = exports.getAgentEditSegments = function getAgentEditS
       complete: complete,
       segments: segments
     };
-  } catch (_unused2) {
+  } catch (_unused3) {
     // Never throw into the shared remote-step handler; degrade to no recording.
     return null;
   }

package/dist/es2019/pm-plugins/main/agent-review-segments.js

@@ -8,20 +8,42 @@ export const REVIEW_MOMENT_AGENT_TYPES_CONFIG = 'platform_editor_backend_review_
 
 // [CCI-17994] Post Stream Review ("Review moment") recording for BE streaming.
 //
-// Sibling to `getAgentShimmerRanges`: same idea of deriving what the agent wrote
-// from a received remote-step batch, but for a DIFFERENT consumer. The shimmer
-// only needs the NEW extent of added content (to draw a skeleton), so it drops
-// pure deletions and expands to whole blocks. The Review moment instead needs, per
-// contiguous change, BOTH the original slice (pre-edit, for undo / "compare with
-// original") and the new slice (for redo), AND it must keep deletions (a removed
-// paragraph is a reviewable change). So this derives the actual changed extents
-// and reconstructs the pre-edit slice from `tr.before`.
+// Sibling to `getAgentShimmerRanges`, but for a different consumer: the shimmer
+// only needs the NEW extent of added content, whereas the Review moment needs, per
+// contiguous change, BOTH the pre-edit slice (for undo) and the new slice (for
+// redo), and must keep deletions. The output is a neutral
+// `AgentRemoteEditReviewData`; `editor-plugin-ai` turns each segment into a coarse
+// `aiContentPositions` entry and reuses the entire FE Review moment pipeline.
 //
-// The output is a neutral `AgentRemoteEditReviewData` (contract in editor-common);
-// `editor-plugin-ai`'s session-context plugin turns each segment into a coarse
-// `aiContentPositions` entry, reusing the entire FE Review moment pipeline.
+// That pipeline requires every coarse entry to be a CLOSED, whole-node slice
+// occupying exactly `[startPos, endPos]`. If a slice is left OPEN (a partial node,
+// e.g. "…\nD") it drops the node wrapper on reconstruction — losing content on undo
+// (data-loss bug) and bleeding highlights into neighbouring nodes. So we expand
+// every change to whole-node outer boundaries and only emit self-consistent
+// entries (see the group loop below).
 
-const clampToDoc = (doc, pos) => Math.min(Math.max(pos, 0), doc.content.size);
+const clampToDoc = (doc, pos) => Math.min(Math.max(pos, 1), doc.content.size);
+const topLevelBlockIndexAt = (doc, pos) => doc.resolve(clampToDoc(doc, pos)).index(0);
+
+// Outer boundaries (before/after tokens) of the top-level node containing `pos`.
+// Slicing between these includes each node's own wrapper tokens, so the slice is
+// CLOSED (`openStart === openEnd === 0`) and preserves node type on reconstruction
+// (a `heading` stays a heading). `depth === 0` means `pos` sits between top-level
+// nodes, so it is already a node boundary.
+// Whether `pos` sits INSIDE a top-level node (depth > 0) vs exactly on a node
+// boundary (depth 0). Unlike `clampToDoc`, this clamps to `[0, size]` (allowing 0)
+// so the doc-start boundary is correctly reported as a boundary, not forced into
+// the first node. Used to tell a structural add/remove (zero-width span at a node
+// boundary) from a text-only insert/delete inside a surviving node.
+const isInsideNode = (doc, pos) => doc.resolve(Math.min(Math.max(pos, 0), doc.content.size)).depth > 0;
+const topLevelNodeStart = (doc, pos) => {
+  const $pos = doc.resolve(clampToDoc(doc, pos));
+  return $pos.depth === 0 ? $pos.pos : $pos.before(1);
+};
+const topLevelNodeEnd = (doc, pos) => {
+  const $pos = doc.resolve(clampToDoc(doc, pos));
+  return $pos.depth === 0 ? $pos.pos : $pos.after(1);
+};
 
 // Map a position in doc_{i+1} forward through the remaining steps to final-doc
 // coords. Mirrors the shimmer's `mapToFinalDoc` — a later step's own inserted
@@ -34,11 +56,31 @@ const mapToFinalDoc = (steps, pos, stepIndex, bias) => {
   return p;
 };
 
+// Map a step's `old` coord (valid in doc_i, this step's input) back to pre-batch
+// (`tr.before`) coords by inverting the PRECEDING steps' maps in reverse. Needed to
+// recover a deletion's original span: its new extent is zero-width, so it cannot be
+// found by inverse-mapping the collapsed new point.
+const mapToBeforeDoc = (steps, pos, stepIndex, bias) => {
+  let p = pos;
+  for (let j = stepIndex - 1; j >= 0; j--) {
+    p = steps[j].getMap().invert().map(p, bias);
+  }
+  return p;
+};
+
+/**
+ * A change region tracked in BOTH coordinate spaces: `[from, to]` in the final doc
+ * (`tr.doc`) and `[origFrom, origTo]` in the pre-batch doc (`tr.before`). Carrying
+ * the original span explicitly lets a deletion (zero-width final extent) still
+ * recover its removed content.
+ */
+
 /**
  * Derive per-change Review moment segments from an agent-authored remote-step
- * batch. Returns `null` when there is nothing to record (no agent steps, or a
- * rebase invalidated our index math, or derivation threw) so the caller can no-op
- * safely — this must never throw into the shared remote-step handler.
+ * batch. Returns `null` when there is nothing to record (no agent steps, agentType
+ * not allowlisted, a rebase invalidated our index math, or derivation threw) so the
+ * caller can no-op safely — this must never throw into the shared remote-step
+ * handler.
  *
  * @param json  the raw received step JSON (carries `agentType` / `agentId` / `userId`)
  * @param steps the parsed PM steps (index-aligned with `json`)
@@ -83,23 +125,11 @@ export const getAgentEditSegments = (json, steps, tr, view) => {
     }
   }
   try {
-    // Compute one segment per step-level StepMap range. Each agent step's changed
-    // extent is taken from its StepMap (the canonical, step-type-agnostic source).
-    // Unlike the shimmer we KEEP zero-width new extents — a pure deletion has
-    // `newEnd === newStart` but is a reviewable `remove`.
-    //
-    // We derive the originalSlice/newSlice PER RANGE (per step) rather than
-    // grouping ranges first and then inverting over a merged range. Grouping
-    // before slicing corrupts the invert-mapping: when multiple discrete
-    // operations (e.g. two deleteNode + one insertNodeAfter) are merged into one
-    // range, mapping that merged range back through the inverted mapping produces
-    // a chimera — a blend of old and new text that never existed in the document.
-    //
-    // The downstream PSR pipeline (mergeOverlappingSegments +
-    // calculateTopLevelNodeSegments) already handles overlapping/adjacent coarse
-    // entries correctly, so grouping here is unnecessary.
-
-    const segments = [];
+    // Each agent step's changed extent in FINAL-doc coords, taken from its StepMap
+    // (the canonical, step-type-agnostic source). Unlike the shimmer we KEEP
+    // zero-width new extents — a pure deletion has `newEnd === newStart` but is a
+    // reviewable `remove`.
+    const ranges = [];
     json.forEach((rawStep, index) => {
       if (typeof (rawStep === null || rawStep === void 0 ? void 0 : rawStep.agentType) !== 'string') {
         return;
@@ -110,55 +140,119 @@ export const getAgentEditSegments = (json, steps, tr, view) => {
         return;
       }
       pmStep.getMap().forEach((oldStart, oldEnd, newStart, newEnd) => {
-        try {
-          // NEW-doc coordinates: map this step's newStart/newEnd forward
-          // through all subsequent steps to get final-doc positions.
-          const finalFrom = mapToFinalDoc(steps, newStart, index, -1);
-          const finalTo = mapToFinalDoc(steps, newEnd, index, 1);
-          const newFrom = clampToDoc(tr.doc, Math.min(finalFrom, finalTo));
-          const newTo = clampToDoc(tr.doc, Math.max(finalFrom, finalTo));
-
-          // ORIGINAL-doc coordinates: map this step's oldStart/oldEnd
-          // BACKWARD through all preceding steps to get pre-batch
-          // (`tr.before`) positions. Each preceding step's StepMap tells
-          // us how positions shifted; we invert that shift by mapping
-          // through the inverted StepMap.
-          //
-          // This is the key difference from using `tr.mapping.invert()`
-          // which inverts ALL steps at once — that produces chimera text
-          // when multiple discrete operations (delete + delete + insert)
-          // interact in the same region. Per-step backward mapping keeps
-          // each operation's original range isolated.
-          let origStart = oldStart;
-          let origEnd = oldEnd;
-          for (let j = index - 1; j >= 0; j--) {
-            const prevMap = steps[j].getMap().invert();
-            origStart = prevMap.map(origStart, -1);
-            origEnd = prevMap.map(origEnd, 1);
-          }
-          const origFrom = clampToDoc(tr.before, Math.min(origStart, origEnd));
-          const origTo = clampToDoc(tr.before, Math.max(origStart, origEnd));
-          const originalSlice = tr.before.slice(origFrom, origTo);
-          const newSlice = tr.doc.slice(newFrom, newTo);
-          const originalEmpty = originalSlice.content.size === 0;
-          const newEmpty = newSlice.content.size === 0;
-          // A truly empty-to-empty region is not a change — skip it.
-          if (originalEmpty && newEmpty) {
-            return;
+        const mappedFrom = mapToFinalDoc(steps, newStart, index, -1);
+        const mappedTo = mapToFinalDoc(steps, newEnd, index, 1);
+        // The same change in pre-batch coords, so a deletion (zero-width new
+        // extent) still carries its original span.
+        const mappedOrigFrom = mapToBeforeDoc(steps, oldStart, index, -1);
+        const mappedOrigTo = mapToBeforeDoc(steps, oldEnd, index, 1);
+        // Skip position-neutral phantom touches: the collab apply stamps same-size
+        // re-writes on unrelated nodes (e.g. `localId` on panels). Drop them only
+        // when byte-identical, so a real same-size replacement is preserved.
+        if (oldEnd - oldStart === newEnd - newStart) {
+          try {
+            const before = tr.before.slice(oldStart, oldEnd);
+            const after = tr.doc.slice(mappedFrom, mappedTo);
+            if (before.content.eq(after.content)) {
+              return;
+            }
+          } catch {
+            // Comparison unsafe: keep the range; whole-block expansion + the
+            // later identical-content skip still guard against phantoms.
           }
-          const kind = originalEmpty ? 'add' : newEmpty ? 'remove' : 'update';
-          segments.push({
-            startPos: newFrom,
-            endPos: newTo,
-            originalSlice,
-            newSlice,
-            kind
-          });
-        } catch {
-          // One bad range must not drop the others.
         }
+        ranges.push({
+          from: mappedFrom,
+          to: mappedTo,
+          origFrom: mappedOrigFrom,
+          origTo: mappedOrigTo
+        });
       });
     });
+    if (!ranges.length) {
+      return null;
+    }
+
+    // Coalesce fragments in the same/adjacent top-level block into one region (a
+    // single agent edit arrives as many small replace fragments); an untouched block
+    // between them splits the run so far-apart edits stay separate. Each region
+    // becomes one coarse segment; the AI plugin refines it further.
+    const sorted = [...ranges].sort((a, b) => a.from - b.from || a.to - b.to);
+    const groups = [];
+    sorted.forEach(range => {
+      const block = topLevelBlockIndexAt(tr.doc, range.from);
+      const current = groups[groups.length - 1];
+      // Coalesce changes in the same or directly-adjacent top-level block (index n /
+      // n+1) into one region, exactly like the shimmer — a single agent edit arrives
+      // as many small fragments. A genuinely untouched block in between (index gap
+      // > 1) splits the run, keeping far-apart edits separate. The original span is
+      // unioned in parallel so a deletion's removed content is preserved.
+      if (current && block <= current.maxBlock + 1) {
+        current.to = Math.max(current.to, range.to);
+        current.maxBlock = Math.max(current.maxBlock, block);
+        current.origFrom = Math.min(current.origFrom, range.origFrom);
+        current.origTo = Math.max(current.origTo, range.origTo);
+      } else {
+        groups.push({
+          from: range.from,
+          to: range.to,
+          maxBlock: block,
+          origFrom: range.origFrom,
+          origTo: range.origTo
+        });
+      }
+    });
+    const segments = [];
+    groups.forEach(group => {
+      try {
+        // Expand the NEW extent to whole-node outer boundaries → a CLOSED slice.
+        // A zero-width new extent at a top-level node boundary is a structural
+        // deletion: leave it empty (do NOT whole-node expand, or it would grab the
+        // unchanged neighbour node that now sits at that point and be discarded as an
+        // identical phantom). A zero-width new extent INSIDE a node is a text-only
+        // deletion from a surviving node, so expand to the whole node (an `update`).
+        const newIsStructuralRemove = group.from === group.to && !isInsideNode(tr.doc, group.from);
+        const newFrom = topLevelNodeStart(tr.doc, Math.min(group.from, group.to));
+        const newTo = newIsStructuralRemove ? newFrom : topLevelNodeEnd(tr.doc, Math.max(group.from, group.to));
+        const newSlice = tr.doc.slice(newFrom, newTo);
+
+        // Build the ORIGINAL slice from the carried pre-batch span, expanded to whole
+        // nodes → a CLOSED slice. Using the carried `origFrom/origTo` (from the
+        // StepMap `old` coords) rather than inverse-mapping the new bounds is what
+        // lets a deletion recover its removed content.
+        //
+        // A zero-width original span is only a true structural ADD when it sits at a
+        // top-level node boundary (inserting a whole new node). A zero-width span
+        // INSIDE a node is a text insertion into that node, so expand to the whole
+        // node (an `update`) — matching how an in-place edit reviews.
+        const origIsStructuralAdd = group.origFrom === group.origTo && !isInsideNode(tr.before, group.origFrom);
+        const origFrom = topLevelNodeStart(tr.before, Math.min(group.origFrom, group.origTo));
+        const origTo = origIsStructuralAdd ? origFrom : topLevelNodeEnd(tr.before, Math.max(group.origFrom, group.origTo));
+        const originalSlice = tr.before.slice(origFrom, origTo);
+        const originalEmpty = originalSlice.content.size === 0;
+        const newEmpty = newSlice.content.size === 0;
+        // A truly empty-to-empty region is not a change — skip it.
+        if (originalEmpty && newEmpty) {
+          return;
+        }
+        // Skip phantom artifacts: a same-size StepMap "touch" at an unrelated node
+        // (e.g. a `localId` stamp on a panel during collab apply) expands to a
+        // segment whose original and new content are identical — not a real change.
+        if (originalSlice.content.eq(newSlice.content)) {
+          return;
+        }
+        const kind = originalEmpty ? 'add' : newEmpty ? 'remove' : 'update';
+        segments.push({
+          startPos: newFrom,
+          endPos: newTo,
+          originalSlice,
+          newSlice,
+          kind
+        });
+      } catch {
+        // One bad group must not drop the others.
+      }
+    });
     if (!segments.length) {
       return null;
     }

package/dist/esm/pm-plugins/main/agent-review-segments.js

@@ -8,21 +8,47 @@ export var REVIEW_MOMENT_AGENT_TYPES_CONFIG = 'platform_editor_backend_review_mo
 
 // [CCI-17994] Post Stream Review ("Review moment") recording for BE streaming.
 //
-// Sibling to `getAgentShimmerRanges`: same idea of deriving what the agent wrote
-// from a received remote-step batch, but for a DIFFERENT consumer. The shimmer
-// only needs the NEW extent of added content (to draw a skeleton), so it drops
-// pure deletions and expands to whole blocks. The Review moment instead needs, per
-// contiguous change, BOTH the original slice (pre-edit, for undo / "compare with
-// original") and the new slice (for redo), AND it must keep deletions (a removed
-// paragraph is a reviewable change). So this derives the actual changed extents
-// and reconstructs the pre-edit slice from `tr.before`.
+// Sibling to `getAgentShimmerRanges`, but for a different consumer: the shimmer
+// only needs the NEW extent of added content, whereas the Review moment needs, per
+// contiguous change, BOTH the pre-edit slice (for undo) and the new slice (for
+// redo), and must keep deletions. The output is a neutral
+// `AgentRemoteEditReviewData`; `editor-plugin-ai` turns each segment into a coarse
+// `aiContentPositions` entry and reuses the entire FE Review moment pipeline.
 //
-// The output is a neutral `AgentRemoteEditReviewData` (contract in editor-common);
-// `editor-plugin-ai`'s session-context plugin turns each segment into a coarse
-// `aiContentPositions` entry, reusing the entire FE Review moment pipeline.
+// That pipeline requires every coarse entry to be a CLOSED, whole-node slice
+// occupying exactly `[startPos, endPos]`. If a slice is left OPEN (a partial node,
+// e.g. "…\nD") it drops the node wrapper on reconstruction — losing content on undo
+// (data-loss bug) and bleeding highlights into neighbouring nodes. So we expand
+// every change to whole-node outer boundaries and only emit self-consistent
+// entries (see the group loop below).
 
 var clampToDoc = function clampToDoc(doc, pos) {
-  return Math.min(Math.max(pos, 0), doc.content.size);
+  return Math.min(Math.max(pos, 1), doc.content.size);
+};
+var topLevelBlockIndexAt = function topLevelBlockIndexAt(doc, pos) {
+  return doc.resolve(clampToDoc(doc, pos)).index(0);
+};
+
+// Outer boundaries (before/after tokens) of the top-level node containing `pos`.
+// Slicing between these includes each node's own wrapper tokens, so the slice is
+// CLOSED (`openStart === openEnd === 0`) and preserves node type on reconstruction
+// (a `heading` stays a heading). `depth === 0` means `pos` sits between top-level
+// nodes, so it is already a node boundary.
+// Whether `pos` sits INSIDE a top-level node (depth > 0) vs exactly on a node
+// boundary (depth 0). Unlike `clampToDoc`, this clamps to `[0, size]` (allowing 0)
+// so the doc-start boundary is correctly reported as a boundary, not forced into
+// the first node. Used to tell a structural add/remove (zero-width span at a node
+// boundary) from a text-only insert/delete inside a surviving node.
+var isInsideNode = function isInsideNode(doc, pos) {
+  return doc.resolve(Math.min(Math.max(pos, 0), doc.content.size)).depth > 0;
+};
+var topLevelNodeStart = function topLevelNodeStart(doc, pos) {
+  var $pos = doc.resolve(clampToDoc(doc, pos));
+  return $pos.depth === 0 ? $pos.pos : $pos.before(1);
+};
+var topLevelNodeEnd = function topLevelNodeEnd(doc, pos) {
+  var $pos = doc.resolve(clampToDoc(doc, pos));
+  return $pos.depth === 0 ? $pos.pos : $pos.after(1);
 };
 
 // Map a position in doc_{i+1} forward through the remaining steps to final-doc
@@ -36,11 +62,31 @@ var mapToFinalDoc = function mapToFinalDoc(steps, pos, stepIndex, bias) {
   return p;
 };
 
+// Map a step's `old` coord (valid in doc_i, this step's input) back to pre-batch
+// (`tr.before`) coords by inverting the PRECEDING steps' maps in reverse. Needed to
+// recover a deletion's original span: its new extent is zero-width, so it cannot be
+// found by inverse-mapping the collapsed new point.
+var mapToBeforeDoc = function mapToBeforeDoc(steps, pos, stepIndex, bias) {
+  var p = pos;
+  for (var j = stepIndex - 1; j >= 0; j--) {
+    p = steps[j].getMap().invert().map(p, bias);
+  }
+  return p;
+};
+
+/**
+ * A change region tracked in BOTH coordinate spaces: `[from, to]` in the final doc
+ * (`tr.doc`) and `[origFrom, origTo]` in the pre-batch doc (`tr.before`). Carrying
+ * the original span explicitly lets a deletion (zero-width final extent) still
+ * recover its removed content.
+ */
+
 /**
  * Derive per-change Review moment segments from an agent-authored remote-step
- * batch. Returns `null` when there is nothing to record (no agent steps, or a
- * rebase invalidated our index math, or derivation threw) so the caller can no-op
- * safely — this must never throw into the shared remote-step handler.
+ * batch. Returns `null` when there is nothing to record (no agent steps, agentType
+ * not allowlisted, a rebase invalidated our index math, or derivation threw) so the
+ * caller can no-op safely — this must never throw into the shared remote-step
+ * handler.
  *
  * @param json  the raw received step JSON (carries `agentType` / `agentId` / `userId`)
  * @param steps the parsed PM steps (index-aligned with `json`)
@@ -91,23 +137,11 @@ export var getAgentEditSegments = function getAgentEditSegments(json, steps, tr,
     }
   }
   try {
-    // Compute one segment per step-level StepMap range. Each agent step's changed
-    // extent is taken from its StepMap (the canonical, step-type-agnostic source).
-    // Unlike the shimmer we KEEP zero-width new extents — a pure deletion has
-    // `newEnd === newStart` but is a reviewable `remove`.
-    //
-    // We derive the originalSlice/newSlice PER RANGE (per step) rather than
-    // grouping ranges first and then inverting over a merged range. Grouping
-    // before slicing corrupts the invert-mapping: when multiple discrete
-    // operations (e.g. two deleteNode + one insertNodeAfter) are merged into one
-    // range, mapping that merged range back through the inverted mapping produces
-    // a chimera — a blend of old and new text that never existed in the document.
-    //
-    // The downstream PSR pipeline (mergeOverlappingSegments +
-    // calculateTopLevelNodeSegments) already handles overlapping/adjacent coarse
-    // entries correctly, so grouping here is unnecessary.
-
-    var segments = [];
+    // Each agent step's changed extent in FINAL-doc coords, taken from its StepMap
+    // (the canonical, step-type-agnostic source). Unlike the shimmer we KEEP
+    // zero-width new extents — a pure deletion has `newEnd === newStart` but is a
+    // reviewable `remove`.
+    var ranges = [];
     json.forEach(function (rawStep, index) {
       if (typeof (rawStep === null || rawStep === void 0 ? void 0 : rawStep.agentType) !== 'string') {
         return;
@@ -118,55 +152,121 @@ export var getAgentEditSegments = function getAgentEditSegments(json, steps, tr,
         return;
       }
       pmStep.getMap().forEach(function (oldStart, oldEnd, newStart, newEnd) {
-        try {
-          // NEW-doc coordinates: map this step's newStart/newEnd forward
-          // through all subsequent steps to get final-doc positions.
-          var finalFrom = mapToFinalDoc(steps, newStart, index, -1);
-          var finalTo = mapToFinalDoc(steps, newEnd, index, 1);
-          var newFrom = clampToDoc(tr.doc, Math.min(finalFrom, finalTo));
-          var newTo = clampToDoc(tr.doc, Math.max(finalFrom, finalTo));
-
-          // ORIGINAL-doc coordinates: map this step's oldStart/oldEnd
-          // BACKWARD through all preceding steps to get pre-batch
-          // (`tr.before`) positions. Each preceding step's StepMap tells
-          // us how positions shifted; we invert that shift by mapping
-          // through the inverted StepMap.
-          //
-          // This is the key difference from using `tr.mapping.invert()`
-          // which inverts ALL steps at once — that produces chimera text
-          // when multiple discrete operations (delete + delete + insert)
-          // interact in the same region. Per-step backward mapping keeps
-          // each operation's original range isolated.
-          var origStart = oldStart;
-          var origEnd = oldEnd;
-          for (var j = index - 1; j >= 0; j--) {
-            var prevMap = steps[j].getMap().invert();
-            origStart = prevMap.map(origStart, -1);
-            origEnd = prevMap.map(origEnd, 1);
-          }
-          var origFrom = clampToDoc(tr.before, Math.min(origStart, origEnd));
-          var origTo = clampToDoc(tr.before, Math.max(origStart, origEnd));
-          var originalSlice = tr.before.slice(origFrom, origTo);
-          var newSlice = tr.doc.slice(newFrom, newTo);
-          var originalEmpty = originalSlice.content.size === 0;
-          var newEmpty = newSlice.content.size === 0;
-          // A truly empty-to-empty region is not a change — skip it.
-          if (originalEmpty && newEmpty) {
-            return;
+        var mappedFrom = mapToFinalDoc(steps, newStart, index, -1);
+        var mappedTo = mapToFinalDoc(steps, newEnd, index, 1);
+        // The same change in pre-batch coords, so a deletion (zero-width new
+        // extent) still carries its original span.
+        var mappedOrigFrom = mapToBeforeDoc(steps, oldStart, index, -1);
+        var mappedOrigTo = mapToBeforeDoc(steps, oldEnd, index, 1);
+        // Skip position-neutral phantom touches: the collab apply stamps same-size
+        // re-writes on unrelated nodes (e.g. `localId` on panels). Drop them only
+        // when byte-identical, so a real same-size replacement is preserved.
+        if (oldEnd - oldStart === newEnd - newStart) {
+          try {
+            var before = tr.before.slice(oldStart, oldEnd);
+            var after = tr.doc.slice(mappedFrom, mappedTo);
+            if (before.content.eq(after.content)) {
+              return;
+            }
+          } catch (_unused) {
+            // Comparison unsafe: keep the range; whole-block expansion + the
+            // later identical-content skip still guard against phantoms.
           }
-          var kind = originalEmpty ? 'add' : newEmpty ? 'remove' : 'update';
-          segments.push({
-            startPos: newFrom,
-            endPos: newTo,
-            originalSlice: originalSlice,
-            newSlice: newSlice,
-            kind: kind
-          });
-        } catch (_unused) {
-          // One bad range must not drop the others.
         }
+        ranges.push({
+          from: mappedFrom,
+          to: mappedTo,
+          origFrom: mappedOrigFrom,
+          origTo: mappedOrigTo
+        });
       });
     });
+    if (!ranges.length) {
+      return null;
+    }
+
+    // Coalesce fragments in the same/adjacent top-level block into one region (a
+    // single agent edit arrives as many small replace fragments); an untouched block
+    // between them splits the run so far-apart edits stay separate. Each region
+    // becomes one coarse segment; the AI plugin refines it further.
+    var sorted = [].concat(ranges).sort(function (a, b) {
+      return a.from - b.from || a.to - b.to;
+    });
+    var groups = [];
+    sorted.forEach(function (range) {
+      var block = topLevelBlockIndexAt(tr.doc, range.from);
+      var current = groups[groups.length - 1];
+      // Coalesce changes in the same or directly-adjacent top-level block (index n /
+      // n+1) into one region, exactly like the shimmer — a single agent edit arrives
+      // as many small fragments. A genuinely untouched block in between (index gap
+      // > 1) splits the run, keeping far-apart edits separate. The original span is
+      // unioned in parallel so a deletion's removed content is preserved.
+      if (current && block <= current.maxBlock + 1) {
+        current.to = Math.max(current.to, range.to);
+        current.maxBlock = Math.max(current.maxBlock, block);
+        current.origFrom = Math.min(current.origFrom, range.origFrom);
+        current.origTo = Math.max(current.origTo, range.origTo);
+      } else {
+        groups.push({
+          from: range.from,
+          to: range.to,
+          maxBlock: block,
+          origFrom: range.origFrom,
+          origTo: range.origTo
+        });
+      }
+    });
+    var segments = [];
+    groups.forEach(function (group) {
+      try {
+        // Expand the NEW extent to whole-node outer boundaries → a CLOSED slice.
+        // A zero-width new extent at a top-level node boundary is a structural
+        // deletion: leave it empty (do NOT whole-node expand, or it would grab the
+        // unchanged neighbour node that now sits at that point and be discarded as an
+        // identical phantom). A zero-width new extent INSIDE a node is a text-only
+        // deletion from a surviving node, so expand to the whole node (an `update`).
+        var newIsStructuralRemove = group.from === group.to && !isInsideNode(tr.doc, group.from);
+        var newFrom = topLevelNodeStart(tr.doc, Math.min(group.from, group.to));
+        var newTo = newIsStructuralRemove ? newFrom : topLevelNodeEnd(tr.doc, Math.max(group.from, group.to));
+        var newSlice = tr.doc.slice(newFrom, newTo);
+
+        // Build the ORIGINAL slice from the carried pre-batch span, expanded to whole
+        // nodes → a CLOSED slice. Using the carried `origFrom/origTo` (from the
+        // StepMap `old` coords) rather than inverse-mapping the new bounds is what
+        // lets a deletion recover its removed content.
+        //
+        // A zero-width original span is only a true structural ADD when it sits at a
+        // top-level node boundary (inserting a whole new node). A zero-width span
+        // INSIDE a node is a text insertion into that node, so expand to the whole
+        // node (an `update`) — matching how an in-place edit reviews.
+        var origIsStructuralAdd = group.origFrom === group.origTo && !isInsideNode(tr.before, group.origFrom);
+        var origFrom = topLevelNodeStart(tr.before, Math.min(group.origFrom, group.origTo));
+        var origTo = origIsStructuralAdd ? origFrom : topLevelNodeEnd(tr.before, Math.max(group.origFrom, group.origTo));
+        var originalSlice = tr.before.slice(origFrom, origTo);
+        var originalEmpty = originalSlice.content.size === 0;
+        var newEmpty = newSlice.content.size === 0;
+        // A truly empty-to-empty region is not a change — skip it.
+        if (originalEmpty && newEmpty) {
+          return;
+        }
+        // Skip phantom artifacts: a same-size StepMap "touch" at an unrelated node
+        // (e.g. a `localId` stamp on a panel during collab apply) expands to a
+        // segment whose original and new content are identical — not a real change.
+        if (originalSlice.content.eq(newSlice.content)) {
+          return;
+        }
+        var kind = originalEmpty ? 'add' : newEmpty ? 'remove' : 'update';
+        segments.push({
+          startPos: newFrom,
+          endPos: newTo,
+          originalSlice: originalSlice,
+          newSlice: newSlice,
+          kind: kind
+        });
+      } catch (_unused2) {
+        // One bad group must not drop the others.
+      }
+    });
     if (!segments.length) {
       return null;
     }
@@ -177,7 +277,7 @@ export var getAgentEditSegments = function getAgentEditSegments(json, steps, tr,
       complete: complete,
       segments: segments
     };
-  } catch (_unused2) {
+  } catch (_unused3) {
     // Never throw into the shared remote-step handler; degrade to no recording.
     return null;
   }

package/dist/types/pm-plugins/main/agent-review-segments.d.ts

@@ -5,9 +5,10 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 export declare const REVIEW_MOMENT_AGENT_TYPES_CONFIG = "platform_editor_backend_review_moment_agent_types";
 /**
  * Derive per-change Review moment segments from an agent-authored remote-step
- * batch. Returns `null` when there is nothing to record (no agent steps, or a
- * rebase invalidated our index math, or derivation threw) so the caller can no-op
- * safely — this must never throw into the shared remote-step handler.
+ * batch. Returns `null` when there is nothing to record (no agent steps, agentType
+ * not allowlisted, a rebase invalidated our index math, or derivation threw) so the
+ * caller can no-op safely — this must never throw into the shared remote-step
+ * handler.
  *
  * @param json  the raw received step JSON (carries `agentType` / `agentId` / `userId`)
  * @param steps the parsed PM steps (index-aligned with `json`)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-collab-edit",
-	"version": "15.0.7",
+	"version": "15.0.8",
 	"description": "Collab Edit plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",