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

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

@@ -61,6 +61,17 @@ function decorationSide(decoration) {
   return (0, _decorationKeys.isDiffDecoration)(decoration) && decoration.spec.side || 0;
 }
 
+/**
+ * Whose change a decoration is part of, or `''` on an unattributed diff — where every decoration
+ * reads as one contributor and the grouping below is unchanged.
+ *
+ * Contributors are kept apart so one stop never covers two of them, since only the tag on the
+ * change stepped to reveals (EDITOR-8932).
+ */
+function contributorOf(decoration) {
+  return (0, _decorationKeys.isDiffDecoration)(decoration) && decoration.spec.attributionKey || '';
+}
+
 /**
  * Collapses decorations that represent one continuous customer-facing edit.
  *
@@ -69,34 +80,52 @@ function decorationSide(decoration) {
  * deletion at the same location should be treated as one replacement. Zero-width decorations
  * (normally deleted-content widgets) can join a group, but cannot extend its range and therefore
  * cannot bridge two otherwise separate edits.
+ *
+ * One group per contributor within a run of touching ranges — see `contributorOf`.
  */
 function groupTouchingDecorations(decorations, isInlineDecoration) {
   if (decorations.length < 2) {
     return decorations;
   }
   var groups = [];
-  var currentGroup = [];
-  var currentGroupFrom = 0;
-  var currentGroupTo = 0;
+  // The groups a following decoration can still join — one per contributor, dropped at every gap.
+  var openGroups = [];
+  var clusterTo = 0;
   var sortedDecorations = (0, _toConsumableArray2.default)(decorations).sort(function (a, b) {
     return a.from === b.from ? a.to - b.to : a.from - b.from;
   });
   sortedDecorations.forEach(function (decoration) {
-    if (currentGroup.length === 0 || decoration.from > currentGroupTo) {
-      currentGroup = [decoration];
-      currentGroupFrom = decoration.from;
-      currentGroupTo = decoration.to;
-      groups.push({
-        decorations: currentGroup,
-        from: currentGroupFrom,
-        to: currentGroupTo
-      });
-      return;
+    var _openGroups$find;
+    // A gap ends the run: nothing before it can be joined.
+    if (decoration.from > clusterTo) {
+      openGroups = [];
     }
-    currentGroup.push(decoration);
-    // A zero-width decoration must not extend the group and bridge a gap.
-    currentGroupTo = Math.max(currentGroupTo, decoration.to);
-    groups[groups.length - 1].to = currentGroupTo;
+    var contributor = contributorOf(decoration);
+    // An unattributed decoration names nobody to keep apart, so it joins whatever is open — a
+    // decision item's own highlight must not split the stop from the tag on its list.
+    var openGroup = (_openGroups$find = openGroups.find(function (group) {
+      return group.contributor === contributor;
+    })) !== null && _openGroups$find !== void 0 ? _openGroups$find : contributor === '' ? openGroups[0] : openGroups.find(function (group) {
+      return group.contributor === '';
+    });
+    if (openGroup === undefined) {
+      var group = {
+        contributor: contributor,
+        decorations: [decoration],
+        from: decoration.from,
+        to: decoration.to
+      };
+      groups.push(group);
+      openGroups = [].concat((0, _toConsumableArray2.default)(openGroups), [group]);
+    } else {
+      // The first contributor to join claims the group, so the next one still starts its own.
+      openGroup.contributor = openGroup.contributor || contributor;
+      openGroup.decorations.push(decoration);
+      openGroup.to = Math.max(openGroup.to, decoration.to);
+    }
+
+    // A zero-width decoration must not extend the run and bridge a gap.
+    clusterTo = Math.max(clusterTo, decoration.to);
   });
   return groups.map(function (_ref) {
     var _ref2, _group$find;
@@ -143,8 +172,8 @@ function groupTouchingDecorations(decorations, isInlineDecoration) {
  * 4. When `doc` is passed: excludes diff-inline decorations whose range has no inline content
  *    (invalid positions, or block-only slices with no text/atoms — e.g. empty blocks)
  * 5. When `confluence_ncs_step_diffing_version_history` is enabled, groups overlapping or
- *    directly touching ranges across decoration types into one result, using the union of all
- *    grouped ranges
+ *    directly touching ranges across decoration types into one result per contributor, using the
+ *    union of all grouped ranges
  *    (zero-width widgets can join a group without extending it). Under
  *    `platform_editor_ai_show_diff_patch_1`, a group that starts with content painting above
  * 	  the content that replaced it — reports that widget as its `scrollTarget` spec,

package/dist/cjs/pm-plugins/utils/baseNodeName.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveBaseNodeName = void 0;
+var _fg = require("@atlaskit/platform-feature-flags/fg");
+/**
+ * A node type's base name, with a schema variant's suffix stripped: `panel`, `panel_c1` and
+ * `panel_c1_root_only` all resolve to `panel`.
+ *
+ * Package-local rather than `getBaseNodeTypeName` from editor-common, which enumerates the variants
+ * it happens to know (`panel_c1` alone) and is shared with features outside this one. Derived
+ * instead of listed, so a variant added later needs no change here: the schema generator names a
+ * variant `<type>_<variant>`, and every other node name in the ADF schema is camelCase, so the
+ * first `_` is the boundary.
+ *
+ * Gated, so the diff behaves exactly as before for anyone outside the rollout.
+ *
+ * For taggability only — this gate is weaker than the ones attribution needs, so resolving a variant
+ * in the styling decisions would move the legacy diff for readers who see no tags.
+ */
+var resolveBaseNodeName = exports.resolveBaseNodeName = function resolveBaseNodeName(name) {
+  return (0, _fg.fg)('confluence_ncs_step_diffing_version_history') ? name.split('_')[0] : name;
+};

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

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isTaggableBlockNodeName = exports.isTaggableBlockNode = void 0;
+var _baseNodeName = require("./baseNodeName");
+/**
+ * Block nodes that host a contributor tag of their own — those whose whole box reads as one change.
+ * Everything that draws a box whatever it holds, plus the two lists that are inserted whole: without
+ * them the tag fell through to the text inside the first item (EDITOR-8932). Bullet and ordered lists
+ * are left out, since their items accrue one at a time. Tables and list items decorate per cell and
+ * per item, with no one-tag-per-block design yet. `blockCard` covers the datasource variant, which is
+ * the same node type.
+ *
+ * Base names only — match with the predicates below, never against `type.name` directly.
+ */
+var TAGGABLE_BLOCK_NODES = new Set(['blockCard', 'blockquote', 'bodiedExtension', 'codeBlock', 'decisionList', 'embedCard', 'expand', 'extension', 'media', 'multiBodiedExtension', 'panel', 'rule', 'taskList']);
+
+/**
+ * Whether this node hosts a contributor tag of its own. Navigation grouping does not consult this:
+ * a run of these one contributor inserted is a single stop, tagged on the leading block.
+ *
+ * Resolved through `resolveBaseNodeName` so a schema variant counts as the type it is a variant of:
+ * `panel_c1` is the panel the table-in-panel schema inserts, and matching on `type.name` left it
+ * untagged (EDITOR-8932).
+ *
+ * By name, because the decoration spec carries `nodeName` rather than the type it came from.
+ */
+var isTaggableBlockNodeName = exports.isTaggableBlockNodeName = function isTaggableBlockNodeName(name) {
+  return name !== undefined && TAGGABLE_BLOCK_NODES.has((0, _baseNodeName.resolveBaseNodeName)(name));
+};
+
+/** As above, from the node type itself. */
+var isTaggableBlockNode = exports.isTaggableBlockNode = function isTaggableBlockNode(nodeType) {
+  return isTaggableBlockNodeName(nodeType.name);
+};

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