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

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

@@ -172,9 +172,44 @@ const calculateNodesForBlockDecoration = ({
   showIndicators = false,
   diffType,
   coarseTableCellsOnly = false,
-  tagMountContext
+  tagMountContext,
+  nodeRanges
 }) => {
   const decorations = [];
+
+  // Exact-nodes path: only reached for a split change (EDITOR-8932), which names the nodes it
+  // owns. Deliberately kept separate from the walk below rather than sharing it.
+  if (nodeRanges) {
+    for (const {
+      from: pos,
+      to: nodeEnd
+    } of nodeRanges) {
+      const node = doc.nodeAt(pos);
+      if (!(node !== null && node !== void 0 && node.isBlock)) {
+        continue;
+      }
+      const isActive = isRangeActive(activeIndexPos, pos, nodeEnd);
+      decorations.push(...createBlockChangedDecoration({
+        attributionKey,
+        change: {
+          from: pos,
+          to: nodeEnd,
+          name: node.type.name
+        },
+        colorScheme,
+        isInserted,
+        isActive,
+        shouldHideDeleted,
+        showContributorTags,
+        showIndicators,
+        doc,
+        diffType,
+        tagMountContext
+      }));
+    }
+    return decorations;
+  }
+
   // Coarse path: inside the large table, only cell/header overlays are kept — the
   // table/row/paragraph decorations there are redundant and cause expensive per-cell
   // re-render. Blocks outside the table keep their normal decorations.
@@ -420,7 +455,7 @@ const calculateDiffDecorationsInner = ({
       tr,
       attributedChanges
     });
-    changes = collapseOverlappingChanges(uncollapsedChanges);
+    changes = collapseOverlappingChanges(uncollapsedChanges, tr.doc);
 
     // Still colours-only: a tags-only diff keeps the plain colour scheme.
     if (attributionColoringEnabled) {
@@ -570,6 +605,8 @@ const calculateDiffDecorationsInner = ({
         doc: tr.doc,
         from: change.fromB,
         to: change.toB,
+        // A split piece's own range no longer covers the container it opened (EDITOR-8932).
+        nodeRanges: change.blockNodeRangesB,
         colorScheme: changeColorScheme,
         ...(isExtendedEnabled(diffType) && {
           isInserted,

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

@@ -1,6 +1,13 @@
 import { simplifyChanges } from 'prosemirror-changeset';
 import { getAttributionKey } from '../decorations/colorSchemes/attributions';
 import { optimizeChanges } from './optimizeChanges';
+
+/**
+ * A change, plus the block nodes it owns when it is one piece of a split — a piece's own range no
+ * longer covers the container it opened. Absent on an unsplit change, which decorates the blocks
+ * inside its own range as before.
+ */
+
 const getAttributionIdentity = change => {
   const identities = new Set();
   for (const span of [...change.deleted, ...change.inserted]) {
@@ -19,20 +26,178 @@ const getAttributionIdentity = change => {
 };
 const byNewDocRange = (left, right) => left.fromB - right.fromB || left.toB - right.toB;
 
+/** Union of the given ranges, with overlapping and touching ones merged. */
+const mergeRanges = ranges => [...ranges].sort((left, right) => left.from - right.from).reduce((merged, range) => {
+  const last = merged[merged.length - 1];
+  if (last && range.from <= last.to) {
+    last.to = Math.max(last.to, range.to);
+    return merged;
+  }
+  return [...merged, {
+    ...range
+  }];
+}, []);
+
+/** Whether `inner` sits wholly inside `outer` and covers less of the document. */
+const isContained = (outer, inner) => inner.toB > inner.fromB && outer.fromB <= inner.fromB && inner.toB <= outer.toB && inner.toB - inner.fromB < outer.toB - outer.fromB;
+
 /**
- * Collapses changes whose new-document ranges strictly overlap. Attribution runs are simplified
- * independently, so runs either side of an unattributed step can come back covering the same
- * characters — which stacks two inline decorations and renders one contributor tag per copy.
+ * The block nodes in `change` whose opening position `ownsPosition` claims. Ownership is by opening
+ * position so a block another contributor added inside a container is not claimed by whoever opened
+ * the container. `undefined` for a range this document cannot resolve, which falls the piece back
+ * to decorating its own range.
+ */
+const blockNodeRanges = (doc, change, ownsPosition) => {
+  if (!doc || change.from >= change.to || change.to > doc.content.size) {
+    return undefined;
+  }
+  const ranges = [];
+  doc.nodesBetween(change.from, change.to, (node, pos) => {
+    if (node.isBlock && ownsPosition(pos) && pos + node.nodeSize <= change.to) {
+      ranges.push({
+        from: pos,
+        to: pos + node.nodeSize
+      });
+    }
+    return true;
+  });
+  return ranges;
+};
+
+/**
+ * Splits a change whose spans name more than one contributor into one change per run of consecutive
+ * spans sharing a key.
  *
- * Merging keeps every span from both sides, so the latest-writer rule still decides whose tag is
- * shown. Ranges that merely touch are left alone, so an unattributed edit next to an attributed one
- * is not credited to it.
+ * `prosemirror-changeset` merges contiguous inserted content into one change while keeping per-span
+ * data, so a panel inserted by one contributor and edited inside by another arrives as a single
+ * change holding every span — and the latest-writer rule credited all of it, panel included, to
+ * whoever wrote last (EDITOR-8932).
  */
-export const collapseOverlappingChanges = changes => {
-  if (changes.length <= 1) {
-    return changes;
+const splitMixedIdentityChanges = (changes, doc) => changes.flatMap(change => {
+  if (getAttributionIdentity(change).mergeable) {
+    return [change];
+  }
+  const runs = [];
+  let offset = change.fromB;
+  for (const span of change.inserted) {
+    const key = getAttributionKey(span.data);
+    const last = runs[runs.length - 1];
+    if (last && last.key === key) {
+      last.to = offset + span.length;
+      last.spans.push(span);
+    } else {
+      runs.push({
+        key,
+        from: offset,
+        to: offset + span.length,
+        spans: [span]
+      });
+    }
+    offset += span.length;
   }
 
+  // The offsets above are only positions if the spans partition the inserted range.
+  if (runs.length < 2 || offset !== change.toB) {
+    return [change];
+  }
+  return runs.map((run, index) => {
+    const owned = blockNodeRanges(doc, {
+      from: change.fromB,
+      to: change.toB
+    }, pos => pos >= run.from && pos < run.to);
+    return {
+      ...change,
+      fromA: index === 0 ? change.fromA : change.toA,
+      fromB: run.from,
+      toB: run.to,
+      deleted: index === 0 ? change.deleted : [],
+      inserted: run.spans,
+      ...(owned ? {
+        blockNodeRangesB: owned
+      } : {})
+    };
+  });
+});
+
+/**
+ * Subtracts every other author's contained change from a change's range, so both contributions
+ * survive. Applies when the contributors arrive as separate changes rather than as spans of one —
+ * the `step` diff type. A contained change by the same author, and one that only partially
+ * overlaps, are left for the collapse below.
+ *
+ * The leading fragment keeps the deleted side, so one deletion is not drawn once per fragment.
+ */
+const splitContainedChanges = (changes, doc) => changes.flatMap(change => {
+  const {
+    key
+  } = getAttributionIdentity(change);
+  const inner = mergeRanges(changes.filter(other => {
+    const otherKey = getAttributionIdentity(other).key;
+    return other !== change && key !== undefined && otherKey !== undefined && otherKey !== key && isContained(change, other);
+  }).map(({
+    fromB,
+    toB
+  }) => ({
+    from: fromB,
+    to: toB
+  })));
+  if (inner.length === 0) {
+    return [change];
+  }
+  const gaps = [];
+  let cursor = change.fromB;
+  for (const {
+    from,
+    to
+  } of inner) {
+    if (from > cursor) {
+      gaps.push({
+        from: cursor,
+        to: from
+      });
+    }
+    cursor = Math.max(cursor, to);
+  }
+  if (change.toB > cursor) {
+    gaps.push({
+      from: cursor,
+      to: change.toB
+    });
+  }
+
+  // Subtracted end to end, so nothing is left to highlight — but the blocks are still owned.
+  const fragments = gaps.length > 0 ? gaps : [{
+    from: change.toB,
+    to: change.toB
+  }];
+  // The outer author's: every block in their range that no inner change opened.
+  const owned = blockNodeRanges(doc, {
+    from: change.fromB,
+    to: change.toB
+  }, pos => !inner.some(({
+    from,
+    to
+  }) => pos >= from && pos < to));
+  return fragments.map((fragment, index) => ({
+    ...change,
+    fromA: index === 0 ? change.fromA : change.toA,
+    fromB: fragment.from,
+    toB: fragment.to,
+    deleted: index === 0 ? change.deleted : [],
+    ...(owned ? {
+      blockNodeRangesB: index === 0 ? owned : []
+    } : {})
+  }));
+});
+
+/**
+ * The blocks a merged change owns. Both sides must name theirs, or the merge falls back to its own
+ * range — narrowing it could drop a block altogether.
+ */
+const mergeBlockNodeRanges = (left, right) => left.blockNodeRangesB && right.blockNodeRangesB ? [...left.blockNodeRangesB, ...right.blockNodeRangesB] : undefined;
+
+/** Unions the changes whose new-document ranges strictly overlap, leaving touching ones alone. */
+const collapse = changes => {
   // A zero-length new-document range paints no inline decoration, so it is kept aside rather than
   // folded into a neighbouring insertion.
   const emptyRanges = changes.filter(change => change.toB <= change.fromB);
@@ -40,13 +205,17 @@ export const collapseOverlappingChanges = changes => {
   for (const change of changes.filter(change => change.toB > change.fromB).sort(byNewDocRange)) {
     const current = collapsed[collapsed.length - 1];
     if (current && change.fromB < current.toB) {
+      const blockNodeRangesB = mergeBlockNodeRanges(current, change);
       collapsed[collapsed.length - 1] = {
         fromA: Math.min(current.fromA, change.fromA),
         toA: Math.max(current.toA, change.toA),
         fromB: Math.min(current.fromB, change.fromB),
         toB: Math.max(current.toB, change.toB),
         deleted: [...current.deleted, ...change.deleted],
-        inserted: [...current.inserted, ...change.inserted]
+        inserted: [...current.inserted, ...change.inserted],
+        ...(blockNodeRangesB ? {
+          blockNodeRangesB
+        } : {})
       };
     } else {
       collapsed.push({
@@ -57,6 +226,23 @@ export const collapseOverlappingChanges = changes => {
   return [...collapsed, ...emptyRanges].sort(byNewDocRange);
 };
 
+/**
+ * Collapses changes whose new-document ranges strictly overlap. Attribution runs are simplified
+ * independently, so runs either side of an unattributed step can come back covering the same
+ * characters — which stacks two inline decorations and renders one contributor tag per copy.
+ *
+ * Merging keeps every span from both sides, so the latest-writer rule still decides whose tag is
+ * shown. Ranges that merely touch are left alone, so an unattributed edit next to an attributed one
+ * is not credited to it.
+ *
+ * Contributors are separated first, by `splitMixedIdentityChanges` and `splitContainedChanges`.
+ * Both leave ranges that only touch, so they survive the collapse.
+ *
+ * Carries no gate of its own: the only caller reaches it through the attributed changeset, which
+ * already requires `confluence_ncs_step_diffing_version_history`.
+ */
+export const collapseOverlappingChanges = (changes, doc) => collapse(splitContainedChanges(splitMixedIdentityChanges(changes, doc), doc));
+
 /**
  * Simplifies and optimizes consecutive changes without crossing an attribution boundary.
  * A change which already contains more than one identity is deliberately kept isolated.

package/dist/es2019/pm-plugins/decorations/colorSchemes/factory.js

@@ -1,3 +1,4 @@
+import { agentBrandColorSchemes } from '@atlaskit/agent-color/agent-brand-color-schemes';
 import { convertToInlineCss } from '@atlaskit/editor-common/lazy-node-view';
 import { getStandardDeletedTextDecorationStyle } from './getStandardDeletedTextDecorationStyle';
 
@@ -115,40 +116,46 @@ const textAccentMap = {
   gray: "var(--ds-text-accent-gray, #505258)",
   lime: "var(--ds-text-accent-lime, #4C6B1F)"
 };
+const getBrand = color => Object.prototype.hasOwnProperty.call(agentBrandColorSchemes, color) ? agentBrandColorSchemes[color] : undefined;
 function bgSubtlest(color) {
-  return bgSubtlestMap[color];
+  var _getBrand$background, _getBrand;
+  return (_getBrand$background = (_getBrand = getBrand(color)) === null || _getBrand === void 0 ? void 0 : _getBrand.background) !== null && _getBrand$background !== void 0 ? _getBrand$background : bgSubtlestMap[color];
 }
 function bgSubtlestPressed(color) {
-  return bgSubtlestPressedMap[color];
+  var _getBrand$background2, _getBrand2;
+  return (_getBrand$background2 = (_getBrand2 = getBrand(color)) === null || _getBrand2 === void 0 ? void 0 : _getBrand2.background) !== null && _getBrand$background2 !== void 0 ? _getBrand$background2 : bgSubtlestPressedMap[color];
 }
 function bgSubtler(color) {
-  return bgSubtlerMap[color];
+  var _getBrand$border, _getBrand3;
+  return (_getBrand$border = (_getBrand3 = getBrand(color)) === null || _getBrand3 === void 0 ? void 0 : _getBrand3.border) !== null && _getBrand$border !== void 0 ? _getBrand$border : bgSubtlerMap[color];
 }
 function bgBolder(color) {
-  return bgBolderMap[color];
+  var _getBrand$bold, _getBrand4;
+  return (_getBrand$bold = (_getBrand4 = getBrand(color)) === null || _getBrand4 === void 0 ? void 0 : _getBrand4.bold) !== null && _getBrand$bold !== void 0 ? _getBrand$bold : bgBolderMap[color];
 }
 function bgSubtlerPressed(color) {
-  return bgSubtlerPressedMap[color];
+  var _getBrand$background3, _getBrand5;
+  return (_getBrand$background3 = (_getBrand5 = getBrand(color)) === null || _getBrand5 === void 0 ? void 0 : _getBrand5.background) !== null && _getBrand$background3 !== void 0 ? _getBrand$background3 : bgSubtlerPressedMap[color];
 }
 function borderAccent(color) {
-  return borderAccentMap[color];
+  var _getBrand$border2, _getBrand6;
+  return (_getBrand$border2 = (_getBrand6 = getBrand(color)) === null || _getBrand6 === void 0 ? void 0 : _getBrand6.border) !== null && _getBrand$border2 !== void 0 ? _getBrand$border2 : borderAccentMap[color];
 }
 function textAccent(color) {
-  return textAccentMap[color];
+  var _getBrand$accentText, _getBrand7;
+  return (_getBrand$accentText = (_getBrand7 = getBrand(color)) === null || _getBrand7 === void 0 ? void 0 : _getBrand7.accentText) !== null && _getBrand$accentText !== void 0 ? _getBrand$accentText : textAccentMap[color];
+}
+function deletedBackground(color) {
+  var _getBrand$emphasisBac, _getBrand8;
+  return (_getBrand$emphasisBac = (_getBrand8 = getBrand(color)) === null || _getBrand8 === void 0 ? void 0 : _getBrand8.emphasisBackground) !== null && _getBrand$emphasisBac !== void 0 ? _getBrand$emphasisBac : bgSubtlest(color);
 }
 
-/**
- * Presentation tokens for a contributor tag in one diff colour.
- *
- * A `bolder` fill rather than the `subtlest` tint the highlight uses: the tag is a label on the
- * change, and at tag size a tint reads as a second, weaker highlight sitting above the real one.
- * `inverse` is the only text tone that reads on a bolder fill, and it needs no per-colour map —
- * which is also why the tag carries no border: the fill alone bounds it.
- */
+/** Contributor tags use a bold fill with a contrasting foreground, including branded schemes. */
 export function getAccentTokens(color) {
+  var _getBrand$boldText, _getBrand9;
   return {
     background: bgBolder(color),
-    text: "var(--ds-text-inverse, #FFFFFF)"
+    text: (_getBrand$boldText = (_getBrand9 = getBrand(color)) === null || _getBrand9 === void 0 ? void 0 : _getBrand9.boldText) !== null && _getBrand$boldText !== void 0 ? _getBrand$boldText : "var(--ds-text-inverse, #FFFFFF)"
   };
 }
 
@@ -170,13 +177,18 @@ function deletedCellOutline(colors) {
 // --- Inserted content styles ---
 
 function insertedInlineBorderColor(colors) {
-  return colors.insertedInlineBorderTone === 'backgroundHovered' ? bgSubtlestHoveredMap[colors.insertColor] : borderAccent(colors.insertColor);
+  var _getBrand$border3, _getBrand0;
+  return colors.insertedInlineBorderTone === 'backgroundHovered' ? (_getBrand$border3 = (_getBrand0 = getBrand(colors.insertColor)) === null || _getBrand0 === void 0 ? void 0 : _getBrand0.border) !== null && _getBrand$border3 !== void 0 ? _getBrand$border3 : bgSubtlestHoveredMap[colors.insertColor] : borderAccent(colors.insertColor);
 }
 
 /** Inline inserted content — default state. */
 export function buildInsertStyle(colors) {
+  const brand = getBrand(colors.insertColor);
   return convertToInlineCss({
     background: bgSubtlest(colors.insertColor),
+    ...(brand ? {
+      color: brand.text
+    } : {}),
     textDecoration: 'underline',
     textDecorationStyle: colors.insertUnderlineStyle,
     textDecorationThickness: "var(--ds-space-025, 2px)",
@@ -196,8 +208,12 @@ export function buildInsertStyleInBlock(colors) {
 
 /** Extended insert style — background + border-bottom underline. */
 export function buildInsertStyleExtended(colors) {
+  const brand = getBrand(colors.insertColor);
   return convertToInlineCss({
     background: bgSubtlest(colors.insertColor),
+    ...(brand ? {
+      color: brand.text
+    } : {}),
     borderBottom: `2px solid ${insertedInlineBorderColor(colors)}`,
     padding: `1px 0 2px`
   });
@@ -213,8 +229,12 @@ export function buildInsertStyleInBlockExtended(colors) {
 
 /** Active state of the extended insert style. */
 export function buildInsertStyleExtendedActive(colors) {
+  const brand = getBrand(colors.insertColor);
   return convertToInlineCss({
     background: bgSubtlerPressed(colors.insertActiveColor),
+    ...(brand ? {
+      color: brand.text
+    } : {}),
     borderBottom: `2px solid ${borderAccent(colors.insertColor)}`,
     padding: `1px 0 2px`
   });
@@ -222,16 +242,24 @@ export function buildInsertStyleExtendedActive(colors) {
 
 /** Extended insert style without underline — background + padding only. */
 export function buildInsertStyleExtendedNoUnderline(colors) {
+  const brand = getBrand(colors.insertColor);
   return convertToInlineCss({
     background: bgSubtlest(colors.insertColor),
+    ...(brand ? {
+      color: brand.text
+    } : {}),
     padding: `1px 0 2px`
   });
 }
 
 /** Active state of the no-underline extended insert style. */
 export function buildInsertStyleExtendedNoUnderlineActive(colors) {
+  const brand = getBrand(colors.insertColor);
   return convertToInlineCss({
     background: bgSubtlerPressed(colors.insertActiveColor),
+    ...(brand ? {
+      color: brand.text
+    } : {}),
     padding: `1px 0 2px`
   });
 }
@@ -245,8 +273,12 @@ export function buildInsertStyleInBlockExtendedNoUnderline(_colors) {
 
 /** Inline inserted content — active/focused state. */
 export function buildInsertStyleActive(colors) {
+  const brand = getBrand(colors.insertColor);
   return convertToInlineCss({
     background: bgSubtlerPressed(colors.insertActiveColor),
+    ...(brand ? {
+      color: brand.text
+    } : {}),
     textDecoration: 'underline',
     textDecorationStyle: colors.insertUnderlineStyle,
     textDecorationThickness: "var(--ds-space-025, 2px)",
@@ -610,7 +642,7 @@ export function buildDeletedInlineContentStyleExtended(colors, isActive = false)
   // Under 'underline' emphasis the highlight stays on its resting tint — the same one hover paints —
   // so only the border carries the emphasis.
   const isUnderlineEmphasis = isActive && usesUnderlineEmphasis(colors);
-  const backgroundColor = isActive && !isUnderlineEmphasis && colors.deletedInlineBorderTone === 'background' ? bgSubtlerPressed(colors.deleteActiveColor) : bgSubtlest(colors.deleteColor);
+  const backgroundColor = isActive && !isUnderlineEmphasis && colors.deletedInlineBorderTone === 'background' ? bgSubtlerPressed(colors.deleteActiveColor) : deletedBackground(colors.deleteColor);
   const borderColor = isUnderlineEmphasis ? borderAccent(colors.deleteActiveColor) : colors.deletedInlineBorderTone === 'background' ? backgroundColor : borderAccent(colors.deleteColor);
   return convertToInlineCss({
     backgroundColor,
@@ -822,7 +854,7 @@ export function getDeletedInlineRevealColors(colors) {
  * paints at rest, so hovering restores the appearance rather than introducing a third one.
  */
 export function getDeletedHighlightHoverColor(colors) {
-  return bgSubtlest(colors.deleteColor);
+  return deletedBackground(colors.deleteColor);
 }
 
 /**

package/dist/es2019/pm-plugins/decorations/colorSchemes/schemes.js

@@ -1,3 +1,4 @@
+import { agentBrandColorSchemes } from '@atlaskit/agent-color/agent-brand-color-schemes';
 import { PARTICIPANT_COLOR_SCHEMES } from './types';
 
 /** Green insertions, red deletions. */
@@ -74,10 +75,12 @@ const createAttributionScheme = color => {
   };
 };
 const attributionColorSchemes = Object.fromEntries(PARTICIPANT_COLOR_SCHEMES.map(color => [color, createAttributionScheme(color)]));
+const brandSchemes = Object.fromEntries(Object.keys(agentBrandColorSchemes).map(scheme => [scheme, createAttributionScheme(scheme)]));
 
 /** Maps public schemes and attribution-only participant slots to their data objects. */
 export const colorSchemeRegistry = {
   ...attributionColorSchemes,
+  ...brandSchemes,
   traditional: traditionalScheme,
   standard: standardScheme
 };

package/dist/es2019/pm-plugins/decorations/colorSchemes/types.js

@@ -5,8 +5,6 @@ export const PARTICIPANT_COLOR_SCHEMES = ['red', 'blue', 'green', 'yellow', 'pur
 
 /** ADS accent hues used by the public and participant colour schemes. */
 
-/** A public scheme or an attribution participant slot resolved internally for one change. */
-
 /**
  * A show-diff colour scheme. Colour fields are ADS hues that `factory.ts` expands into token paths;
  * the rest encode structural differences no colour can express. Ring widths, padding, radius and

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

@@ -4,6 +4,7 @@ import { Decoration } from '@atlaskit/editor-prosemirror/view';
 import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
 import { fg } from '@atlaskit/platform-feature-flags/fg';
 import { isExtendedEnabled } from '../isExtendedEnabled';
+import { isTaggableBlockNode } from '../utils/taggableBlockNodes';
 import { buildAddedCellOverlayRoundedStyle, buildAddedCellOverlayStyle, buildDeletedBlockNodeStyle, buildDeletedCellOverlayRoundedStyle, buildDeletedCellOverlayStyle, buildInsertedBlockNodeStyle } from './colorSchemes/factory';
 import { colorSchemeRegistry, getLegacyColorScheme } from './colorSchemes/schemes';
 import { createBlockIndicatorAnchorWidgets } from './createAnchorDecorationWidgets';
@@ -23,23 +24,28 @@ const UNSTYLED_NODES = ['mediaSingle', 'mediaGroup', 'table',
 'heading', 'hardBreak', 'decisionList', 'taskList', 'bulletList', 'orderedList', 'layoutSection'];
 const CELL_NODES = ['tableCell', 'tableHeader'];
 
-/**
- * Block nodes that host a contributor tag of their own — those whose whole box reads as one change.
- * Lists and tables are excluded: they decorate per item and per cell, with no one-tag-per-block
- * design yet. `blockCard` covers the datasource variant, which is the same node type.
- */
-const TAGGABLE_BLOCK_NODES = new Set(['blockCard', 'blockquote', 'bodiedExtension', 'codeBlock', 'embedCard', 'expand', 'extension', 'media', 'multiBodiedExtension', 'panel', 'rule']);
-
 /** Panels, rules and media can also sit in a table cell, which is out of scope for block tags. */
 const isInsideTable = (doc, pos) => findParentNodeClosestToPos(doc.resolve(pos), node => node.type.name === 'table') !== undefined;
 
-/** Whether this block can host a contributor tag of its own. */
+/**
+ * Whether this block can host a contributor tag of its own.
+ *
+ * The node type is resolved from the document rather than matched on `change.name`, so a schema
+ * variant is recognised as the type it varies — see `isTaggableBlockNode`. `from` is the node's own
+ * position, so `nodeAt` returns exactly the node being decorated.
+ */
 const canTagBlock = ({
   diffType,
   doc,
-  from,
-  name
-}) => doc !== undefined && isExtendedEnabled(diffType) && TAGGABLE_BLOCK_NODES.has(name) && !isInsideTable(doc, from);
+  from
+}) => {
+  var _doc$nodeAt;
+  if (doc === undefined || !isExtendedEnabled(diffType)) {
+    return false;
+  }
+  const nodeType = (_doc$nodeAt = doc.nodeAt(from)) === null || _doc$nodeAt === void 0 ? void 0 : _doc$nodeAt.type;
+  return nodeType !== undefined && isTaggableBlockNode(nodeType) && !isInsideTable(doc, from);
+};
 
 /** Positioning context for the cell overlay widget decorations. */
 const cellPositionStyle = convertToInlineCss({
@@ -176,8 +182,7 @@ export const createBlockChangedDecoration = ({
   const shouldTagBlock = showContributorTags && canTagBlock({
     diffType,
     doc,
-    from: change.from,
-    name: change.name
+    from: change.from
   });
   // Named so this block's own tag can position against it; see `createContributorTagWidget`.
   const tagAnchorName = shouldTagBlock && isContributorTagWidgetEnabled() ? buildAnchorDecorationKey({
@@ -221,7 +226,9 @@ export const createBlockChangedDecoration = ({
       key: 'cell-overlay-decoration'
     }));
   }
-  // isInserted is only read under the extended experience, so pass it unconditionally.
+  // isInserted is only read under the extended experience, so pass it unconditionally. `change.name`
+  // verbatim: base-name resolution stays in `canTagBlock`, which needs tags on, so a schema
+  // variant's legacy style is untouched — see `resolveBaseNodeName`.
   const nodeStyle = getBlockNodeStyle({
     nodeName: change.name,
     colorScheme,
@@ -254,6 +261,8 @@ export const createBlockChangedDecoration = ({
     })));
   }
   if (decorations.length === 0) {
+    // An unstyled node type (paragraph, heading, list, layout, …) emits no decoration at all, so
+    // there is nothing for a tag to hang off even when the node type would otherwise be taggable.
     return decorations;
   }
   if (showIndicators && doc && isExtendedEnabled(diffType)) {