@atlaskit/editor-plugin-paste 18.0.4 → 18.0.5

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @atlaskit/editor-plugin-paste
 
+## 18.0.5
+
+### Patch Changes
+
+- [`4a3a84237c82a`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/4a3a84237c82a) -
+  Behind the `platform_editor_paste_autoconvert_robustness` experiment: paste auto-conversion no
+  longer waits for the smart link provider before inserting pasted content, and the macro
+  replacement range is derived from the applied transaction steps instead of the slice size so the
+  pasted link can no longer be left behind alongside the macro. If the pasted link can no longer be
+  located when the request settles (for example it was unlinked in the meantime), nothing is
+  replaced — content is never matched by proximity to a stale position, which could otherwise
+  convert a different, unrelated link to the same URL. Behaviour is unchanged when the experiment is
+  off.
+- Updated dependencies
+
 ## 18.0.4
 
 ### Patch Changes

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

@@ -417,7 +417,7 @@ function createPlugin(schema, dispatchAnalyticsEvent, dispatch, featureFlags, pl
             }
 
             // run macro autoconvert prior to other conversions
-            if ((0, _handlers.handleMacroAutoConvert)(text, markdownSlice, pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$c = pluginInjectionApi.card) === null || _pluginInjectionApi$c === void 0 || (_pluginInjectionApi$c = _pluginInjectionApi$c.actions) === null || _pluginInjectionApi$c === void 0 ? void 0 : _pluginInjectionApi$c.queueCardsFromChangedTr, pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$e = pluginInjectionApi.extension) === null || _pluginInjectionApi$e === void 0 || (_pluginInjectionApi$e = _pluginInjectionApi$e.actions) === null || _pluginInjectionApi$e === void 0 ? void 0 : _pluginInjectionApi$e.runMacroAutoConvert, cardOptions, extensionAutoConverter)(state, dispatch, view)) {
+            if ((0, _handlers.handleMacroAutoConvert)(text, markdownSlice, pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$c = pluginInjectionApi.card) === null || _pluginInjectionApi$c === void 0 || (_pluginInjectionApi$c = _pluginInjectionApi$c.actions) === null || _pluginInjectionApi$c === void 0 ? void 0 : _pluginInjectionApi$c.queueCardsFromChangedTr, pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$e = pluginInjectionApi.extension) === null || _pluginInjectionApi$e === void 0 || (_pluginInjectionApi$e = _pluginInjectionApi$e.actions) === null || _pluginInjectionApi$e === void 0 ? void 0 : _pluginInjectionApi$e.runMacroAutoConvert, cardOptions, extensionAutoConverter, editorAnalyticsAPI)(state, dispatch, view)) {
               // TODO: ED-26959 - handleMacroAutoConvert dispatch twice, so we can't use the helper
               (0, _analytics2.sendPasteAnalyticsEvent)(editorAnalyticsAPI)(view, event, markdownSlice, {
                 type: _analytics.PasteTypes.markdown
@@ -515,7 +515,7 @@ function createPlugin(schema, dispatchAnalyticsEvent, dispatch, featureFlags, pl
           }
 
           // run macro autoconvert prior to other conversions
-          if ((0, _handlers.handleMacroAutoConvert)(text, slice, pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$c2 = pluginInjectionApi.card) === null || _pluginInjectionApi$c2 === void 0 || (_pluginInjectionApi$c2 = _pluginInjectionApi$c2.actions) === null || _pluginInjectionApi$c2 === void 0 ? void 0 : _pluginInjectionApi$c2.queueCardsFromChangedTr, pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$e2 = pluginInjectionApi.extension) === null || _pluginInjectionApi$e2 === void 0 || (_pluginInjectionApi$e2 = _pluginInjectionApi$e2.actions) === null || _pluginInjectionApi$e2 === void 0 ? void 0 : _pluginInjectionApi$e2.runMacroAutoConvert, cardOptions, extensionAutoConverter)(state, dispatch, view)) {
+          if ((0, _handlers.handleMacroAutoConvert)(text, slice, pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$c2 = pluginInjectionApi.card) === null || _pluginInjectionApi$c2 === void 0 || (_pluginInjectionApi$c2 = _pluginInjectionApi$c2.actions) === null || _pluginInjectionApi$c2 === void 0 ? void 0 : _pluginInjectionApi$c2.queueCardsFromChangedTr, pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$e2 = pluginInjectionApi.extension) === null || _pluginInjectionApi$e2 === void 0 || (_pluginInjectionApi$e2 = _pluginInjectionApi$e2.actions) === null || _pluginInjectionApi$e2 === void 0 ? void 0 : _pluginInjectionApi$e2.runMacroAutoConvert, cardOptions, extensionAutoConverter, editorAnalyticsAPI)(state, dispatch, view)) {
             // TODO: ED-26959 - handleMacroAutoConvert dispatch twice, so we can't use the helper
             (0, _analytics2.sendPasteAnalyticsEvent)(editorAnalyticsAPI)(view, event, slice, {
               type: _analytics.PasteTypes.richText

package/dist/cjs/pm-plugins/util/handlers.js

@@ -642,7 +642,7 @@ function _getSmartLinkAdf() {
   }));
   return _getSmartLinkAdf.apply(this, arguments);
 }
-function insertAutoMacro(slice, macro, view, from, to) {
+function insertAutoMacroOld(slice, macro, view, from, to) {
   if (view) {
     // insert the text or linkified/md-converted clipboard data
     var selection = view.state.tr.selection;
@@ -669,7 +669,168 @@ function insertAutoMacro(slice, macro, view, from, to) {
   }
   return false;
 }
-function handleMacroAutoConvert(text, slice, queueCardsFromChangedTr, runMacroAutoConvert, cardsOptions, extensionAutoConverter) {
+
+/**
+ * Replacement for `insertAutoMacroOld` behind
+ * `platform_editor_paste_autoconvert_robustness`.
+ *
+ * Identical in shape, except that the range the macro replaces is derived from the steps
+ * that were actually applied rather than from `slice.size`. `slice.size` is the slice's
+ * own measure and does not account for ProseMirror's fitting behaviour in
+ * `replaceRange`/`replaceSelection`, so the two can disagree — and when they do the macro
+ * is inserted without removing the text it should replace, leaving both the pasted text
+ * and the macro in the document.
+ */
+function insertAutoMacroNew(slice, macro, view, from, to) {
+  if (!view) {
+    return false;
+  }
+  var selection = view.state.selection;
+  var hasExplicitRange = typeof from === 'number' && typeof to === 'number';
+  var replaceFrom = hasExplicitRange ? from : selection.from;
+  var replaceTo = hasExplicitRange ? to : selection.to;
+
+  // insert the text or linkified/md-converted clipboard data
+  var tr = hasExplicitRange ? view.state.tr.replaceRange(replaceFrom, replaceTo, slice) : view.state.tr.replaceSelection(slice);
+  var insertedFrom = tr.mapping.map(replaceFrom, -1);
+  var insertedTo = tr.mapping.map(replaceTo, 1);
+  view.dispatch(tr);
+
+  // Leave the document alone rather than replacing an implausible range.
+  if (insertedFrom >= insertedTo || insertedTo > view.state.doc.content.size) {
+    return true;
+  }
+
+  // replace the text with the macro as a separate transaction
+  // so the autoconversion generates 2 undo steps
+  var macroTr = (0, _closeHistory.closeHistory)(view.state.tr).replaceRangeWith(insertedFrom, insertedTo, macro).scrollIntoView();
+  (0, _card.addLinkMetadata)(view.state.selection, macroTr, {
+    inputMethod: _analytics.INPUT_METHOD.CLIPBOARD,
+    cardAction: 'AUTO_CONVERT'
+  });
+  view.dispatch(macroTr);
+  return true;
+}
+function insertAutoMacro(slice, macro, view, from, to) {
+  return (0, _isExperimentEnabled.isExperimentEnabled)('platform_editor_paste_autoconvert_robustness') ? insertAutoMacroNew(slice, macro, view, from, to) : insertAutoMacroOld(slice, macro, view, from, to);
+}
+
+/**
+ * Locates the range currently occupied by a link that we pasted earlier.
+ *
+ * Positions recorded before an async gap can drift or be invalidated entirely by
+ * concurrent edits, collaborative changes and `appendTransaction` hooks, so the
+ * recorded range is verified against the document before it is used. If it no longer
+ * holds the pasted link the link is re-located by href, preferring the occurrence
+ * closest to where it was last seen.
+ *
+ * Returns `undefined` when the link cannot be found, so callers can leave the
+ * document alone rather than replacing whatever happens to sit at a stale position.
+ */
+/**
+ * Whether every text node spanning [from, to) carries a `link` mark pointing at `url`,
+ * with no gaps or uncovered portions.
+ */
+function rangeIsExactLinkMark(doc, from, to, url, linkMarkType) {
+  var matches = true;
+  var coveredTo = from;
+  doc.nodesBetween(from, to, function (node, pos) {
+    if (!matches || pos >= to) {
+      return false;
+    }
+    if (!node.isLeaf) {
+      // A container node — e.g. the paragraph the link sits in. `nodesBetween` visits
+      // these on the way down to the text node(s) we actually care about; keep
+      // descending into it rather than treating it as a mismatch.
+      return true;
+    }
+    if (!node.isText) {
+      // A non-text leaf (e.g. an inline card) cannot carry the link mark.
+      matches = false;
+      return false;
+    }
+    var linkMark = linkMarkType.isInSet(node.marks);
+    if (!linkMark || linkMark.attrs.href !== url) {
+      matches = false;
+      return false;
+    }
+    coveredTo = Math.min(pos + node.nodeSize, to);
+    return true;
+  });
+  return matches && coveredTo === to;
+}
+
+/**
+ * `from`/`to` are not a one-off snapshot: they come from `pastedMacroPositions`, which the
+ * paste plugin's `mapping` hook (`plugin-factory.ts`) maps through every transaction
+ * applied while the smart link request is in flight, via `tr.mapping.map(position)`. So
+ * this covers every edit ProseMirror can express as a position mapping — typing,
+ * deleting, or moving content elsewhere in the same edit all keep `from`/`to` pointing at
+ * the same logical span.
+ *
+ * It stops covering that span only when the span itself no longer represents our pasted
+ * link — the link was unlinked, or its content was replaced outright. Deliberately no
+ * fallback search for "the nearest link with the same href" is done: with multiple links
+ * to the same URL in the document, a proximity search cannot tell which one we pasted, so
+ * it risks silently replacing an occurrence we were never asked to touch, and it requires
+ * an O(doc size) scan on every fallback to do it. Leaving the tracked link as a link is
+ * the safe outcome here, and it's what happens when this function returns `undefined`.
+ */
+function findPastedLinkRange(state, url, from, to) {
+  var doc = state.doc,
+    schema = state.schema;
+  var linkMarkType = schema.marks.link;
+  var docSize = doc.content.size;
+  if (!linkMarkType || typeof from !== 'number' || typeof to !== 'number' || from < 0 || from >= to || to > docSize) {
+    return undefined;
+  }
+
+  // Text equality alone is not enough: if the link was unlinked (mark removed) while
+  // the smart link request was in flight, the text can still read as the URL even
+  // though it is no longer a link, and replacing it would destroy content that is no
+  // longer ours to replace.
+  if (doc.textBetween(from, to) === url && rangeIsExactLinkMark(doc, from, to, url, linkMarkType)) {
+    return {
+      from: from,
+      to: to
+    };
+  }
+  return undefined;
+}
+
+/**
+ * Swaps a link that was already pasted into the document for its macro equivalent.
+ *
+ * Used when smart links could not resolve the URL, so the macro autoconversion is the
+ * fallback. Does nothing if the link can no longer be found — for example because a
+ * smart card has already replaced it — which is preferable to replacing unrelated
+ * content at a stale position.
+ */
+function replacePastedLinkWithMacro(view, macro, url, from, to, editorAnalyticsAPI) {
+  var range = findPastedLinkRange(view.state, url, from, to);
+  if (!range) {
+    // Metric for how often the tracked pasted link could no longer be found once the
+    // smart link request settled, so the assumption that this is rare is measurable
+    // rather than assumed.
+    editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.fireAnalyticsEvent({
+      action: _analytics.ACTION.ERRORED,
+      actionSubject: _analytics.ACTION_SUBJECT.SMART_LINK,
+      eventType: _analytics.EVENT_TYPE.OPERATIONAL,
+      attributes: {
+        error: 'macro-auto-convert-pasted-link-not-found'
+      }
+    });
+    return false;
+  }
+  var macroTr = (0, _closeHistory.closeHistory)(view.state.tr).replaceRangeWith(range.from, range.to, macro).scrollIntoView();
+  (0, _card.addLinkMetadata)(view.state.selection, macroTr, {
+    inputMethod: _analytics.INPUT_METHOD.CLIPBOARD,
+    cardAction: 'AUTO_CONVERT'
+  });
+  view.dispatch(macroTr);
+  return true;
+}
+function handleMacroAutoConvert(text, slice, queueCardsFromChangedTr, runMacroAutoConvert, cardsOptions, extensionAutoConverter, editorAnalyticsAPI) {
   return function (state, dispatch, view) {
     var macro = null;
 
@@ -697,23 +858,50 @@ function handleMacroAutoConvert(text, slice, queueCardsFromChangedTr, runMacroAu
         if (!view) {
           throw new Error('View is missing');
         }
+        var autoConvertMacro = macro;
 
         // eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
         var trackingId = (0, _uuid.v4)();
         var trackingFrom = "handleMacroAutoConvert-from-".concat(trackingId);
         var trackingTo = "handleMacroAutoConvert-to-".concat(trackingId);
+        if ((0, _isExperimentEnabled.isExperimentEnabled)('platform_editor_paste_autoconvert_robustness')) {
+          // Insert the pasted content straight away. The smart link provider is only
+          // consulted to decide whether the inserted link should later be swapped for
+          // a macro, so it does not need to gate the insert — otherwise every
+          // autoconvertible paste appears to do nothing until a network round trip
+          // completes.
+          var insertedRange;
+          handleMarkdownWithInsertedRange(slice, queueCardsFromChangedTr, function (range) {
+            insertedRange = range;
+          })(state, dispatch);
+          if (!insertedRange) {
+            return true;
+          }
+          (0, _commands.startTrackingPastedMacroPositions)((0, _defineProperty2.default)((0, _defineProperty2.default)({}, trackingFrom, insertedRange.from), trackingTo, insertedRange.to))(view.state, dispatch);
+          getSmartLinkAdf(text, 'inline', cardsOptions).catch(function () {
+            // Smart links could not resolve the URL, so fall back to the macro.
+            // we use view.state rather than state because state becomes a stale
+            // state reference after getSmartLinkAdf's async work
+            var _getPastePluginState = (0, _pluginFactory.getPluginState)(view.state),
+              pastedMacroPositions = _getPastePluginState.pastedMacroPositions;
+            replacePastedLinkWithMacro(view, autoConvertMacro, text, pastedMacroPositions[trackingFrom], pastedMacroPositions[trackingTo], editorAnalyticsAPI);
+          }).finally(function () {
+            (0, _commands.stopTrackingPastedMacroPositions)([trackingFrom, trackingTo])(view.state, dispatch);
+          });
+          return true;
+        }
         (0, _commands.startTrackingPastedMacroPositions)((0, _defineProperty2.default)((0, _defineProperty2.default)({}, trackingFrom, state.selection.from), trackingTo, state.selection.to))(state, dispatch);
         getSmartLinkAdf(text, 'inline', cardsOptions).then(function () {
           // we use view.state rather than state because state becomes a stale
           // state reference after getSmartLinkAdf's async work
-          var _getPastePluginState = (0, _pluginFactory.getPluginState)(view.state),
-            pastedMacroPositions = _getPastePluginState.pastedMacroPositions;
+          var _getPastePluginState2 = (0, _pluginFactory.getPluginState)(view.state),
+            pastedMacroPositions = _getPastePluginState2.pastedMacroPositions;
           if (dispatch) {
             handleMarkdown(slice, queueCardsFromChangedTr, pastedMacroPositions[trackingFrom], pastedMacroPositions[trackingTo])(view.state, dispatch);
           }
         }).catch(function () {
-          var _getPastePluginState2 = (0, _pluginFactory.getPluginState)(view.state),
-            pastedMacroPositions = _getPastePluginState2.pastedMacroPositions;
+          var _getPastePluginState3 = (0, _pluginFactory.getPluginState)(view.state),
+            pastedMacroPositions = _getPastePluginState3.pastedMacroPositions;
           insertAutoMacro(slice, macro, view, pastedMacroPositions[trackingFrom], pastedMacroPositions[trackingTo]);
         }).finally(function () {
           (0, _commands.stopTrackingPastedMacroPositions)([trackingFrom, trackingTo])(view.state, dispatch);
@@ -1007,6 +1195,36 @@ function resolveParagraphMarks(marks, destinationBlockMarkAttrs, shouldNormalize
   }
   return marks;
 }
+
+/**
+ * Variant of `handleMarkdown` used by macro auto-conversion behind
+ * `platform_editor_paste_autoconvert_robustness`.
+ *
+ * Differs in two ways: the inserted range is derived from the steps that were applied
+ * rather than from `markdownSlice.size`, which does not account for ProseMirror's fitting
+ * behaviour; and that range is reported back through `onInsert` so the caller can track
+ * the inserted link across the async gap before deciding whether to swap it for a macro.
+ */
+function handleMarkdownWithInsertedRange(markdownSlice, queueCardsFromChangedTr, onInsert) {
+  return function (state, dispatch) {
+    var tr = (0, _closeHistory.closeHistory)(state.tr);
+    var replaceFrom = tr.selection.from;
+    var replaceTo = tr.selection.to;
+    tr.replaceSelection(markdownSlice);
+    var insertedFrom = tr.mapping.map(replaceFrom, -1);
+    var insertedTo = tr.mapping.map(replaceTo, 1);
+    tr.setSelection(_state.TextSelection.near(tr.doc.resolve(Math.min(insertedTo, tr.doc.content.size)), -1));
+    queueCardsFromChangedTr === null || queueCardsFromChangedTr === void 0 || queueCardsFromChangedTr(state, tr, _analytics.INPUT_METHOD.CLIPBOARD);
+    if (dispatch) {
+      dispatch(tr.scrollIntoView());
+      onInsert({
+        from: insertedFrom,
+        to: insertedTo
+      });
+    }
+    return true;
+  };
+}
 function handleParagraphBlockMarks(state, slice) {
   var _findParentNodeOfType2;
   if (slice.content.size === 0) {

package/dist/es2019/pm-plugins/main.js

@@ -376,7 +376,7 @@ export function createPlugin(schema, dispatchAnalyticsEvent, dispatch, featureFl
             }
 
             // run macro autoconvert prior to other conversions
-            if (handleMacroAutoConvert(text, markdownSlice, pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$c = pluginInjectionApi.card) === null || _pluginInjectionApi$c === void 0 ? void 0 : (_pluginInjectionApi$c2 = _pluginInjectionApi$c.actions) === null || _pluginInjectionApi$c2 === void 0 ? void 0 : _pluginInjectionApi$c2.queueCardsFromChangedTr, pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$e = pluginInjectionApi.extension) === null || _pluginInjectionApi$e === void 0 ? void 0 : (_pluginInjectionApi$e2 = _pluginInjectionApi$e.actions) === null || _pluginInjectionApi$e2 === void 0 ? void 0 : _pluginInjectionApi$e2.runMacroAutoConvert, cardOptions, extensionAutoConverter)(state, dispatch, view)) {
+            if (handleMacroAutoConvert(text, markdownSlice, pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$c = pluginInjectionApi.card) === null || _pluginInjectionApi$c === void 0 ? void 0 : (_pluginInjectionApi$c2 = _pluginInjectionApi$c.actions) === null || _pluginInjectionApi$c2 === void 0 ? void 0 : _pluginInjectionApi$c2.queueCardsFromChangedTr, pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$e = pluginInjectionApi.extension) === null || _pluginInjectionApi$e === void 0 ? void 0 : (_pluginInjectionApi$e2 = _pluginInjectionApi$e.actions) === null || _pluginInjectionApi$e2 === void 0 ? void 0 : _pluginInjectionApi$e2.runMacroAutoConvert, cardOptions, extensionAutoConverter, editorAnalyticsAPI)(state, dispatch, view)) {
               // TODO: ED-26959 - handleMacroAutoConvert dispatch twice, so we can't use the helper
               sendPasteAnalyticsEvent(editorAnalyticsAPI)(view, event, markdownSlice, {
                 type: PasteTypes.markdown
@@ -476,7 +476,7 @@ export function createPlugin(schema, dispatchAnalyticsEvent, dispatch, featureFl
           }
 
           // run macro autoconvert prior to other conversions
-          if (handleMacroAutoConvert(text, slice, pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$c3 = pluginInjectionApi.card) === null || _pluginInjectionApi$c3 === void 0 ? void 0 : (_pluginInjectionApi$c4 = _pluginInjectionApi$c3.actions) === null || _pluginInjectionApi$c4 === void 0 ? void 0 : _pluginInjectionApi$c4.queueCardsFromChangedTr, pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$e3 = pluginInjectionApi.extension) === null || _pluginInjectionApi$e3 === void 0 ? void 0 : (_pluginInjectionApi$e4 = _pluginInjectionApi$e3.actions) === null || _pluginInjectionApi$e4 === void 0 ? void 0 : _pluginInjectionApi$e4.runMacroAutoConvert, cardOptions, extensionAutoConverter)(state, dispatch, view)) {
+          if (handleMacroAutoConvert(text, slice, pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$c3 = pluginInjectionApi.card) === null || _pluginInjectionApi$c3 === void 0 ? void 0 : (_pluginInjectionApi$c4 = _pluginInjectionApi$c3.actions) === null || _pluginInjectionApi$c4 === void 0 ? void 0 : _pluginInjectionApi$c4.queueCardsFromChangedTr, pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$e3 = pluginInjectionApi.extension) === null || _pluginInjectionApi$e3 === void 0 ? void 0 : (_pluginInjectionApi$e4 = _pluginInjectionApi$e3.actions) === null || _pluginInjectionApi$e4 === void 0 ? void 0 : _pluginInjectionApi$e4.runMacroAutoConvert, cardOptions, extensionAutoConverter, editorAnalyticsAPI)(state, dispatch, view)) {
             // TODO: ED-26959 - handleMacroAutoConvert dispatch twice, so we can't use the helper
             sendPasteAnalyticsEvent(editorAnalyticsAPI)(view, event, slice, {
               type: PasteTypes.richText

package/dist/es2019/pm-plugins/util/handlers.js

@@ -1,7 +1,7 @@
 // eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
 import { v4 as uuid } from 'uuid';
 import { transformContainerNodes } from '@atlaskit/adf-utils/transforms';
-import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { ACTION, ACTION_SUBJECT, EVENT_TYPE, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
 import { addLinkMetadata } from '@atlaskit/editor-common/card';
 import { insideTable } from '@atlaskit/editor-common/core-utils';
 import { getBlockMarkAttrs, getFirstParagraphBlockMarkAttrs, reconcileBlockMarkForContainerAtPos, reconcileBlockMarkForParagraphAtPos, reconcileBlockMarkInRange } from '@atlaskit/editor-common/lists';
@@ -608,7 +608,7 @@ async function getSmartLinkAdf(text, type, cardOptions) {
   const provider = await cardOptions.provider;
   return await provider.resolve(text, type);
 }
-function insertAutoMacro(slice, macro, view, from, to) {
+function insertAutoMacroOld(slice, macro, view, from, to) {
   if (view) {
     // insert the text or linkified/md-converted clipboard data
     const selection = view.state.tr.selection;
@@ -635,7 +635,172 @@ function insertAutoMacro(slice, macro, view, from, to) {
   }
   return false;
 }
-export function handleMacroAutoConvert(text, slice, queueCardsFromChangedTr, runMacroAutoConvert, cardsOptions, extensionAutoConverter) {
+
+/**
+ * Replacement for `insertAutoMacroOld` behind
+ * `platform_editor_paste_autoconvert_robustness`.
+ *
+ * Identical in shape, except that the range the macro replaces is derived from the steps
+ * that were actually applied rather than from `slice.size`. `slice.size` is the slice's
+ * own measure and does not account for ProseMirror's fitting behaviour in
+ * `replaceRange`/`replaceSelection`, so the two can disagree — and when they do the macro
+ * is inserted without removing the text it should replace, leaving both the pasted text
+ * and the macro in the document.
+ */
+function insertAutoMacroNew(slice, macro, view, from, to) {
+  if (!view) {
+    return false;
+  }
+  const {
+    selection
+  } = view.state;
+  const hasExplicitRange = typeof from === 'number' && typeof to === 'number';
+  const replaceFrom = hasExplicitRange ? from : selection.from;
+  const replaceTo = hasExplicitRange ? to : selection.to;
+
+  // insert the text or linkified/md-converted clipboard data
+  const tr = hasExplicitRange ? view.state.tr.replaceRange(replaceFrom, replaceTo, slice) : view.state.tr.replaceSelection(slice);
+  const insertedFrom = tr.mapping.map(replaceFrom, -1);
+  const insertedTo = tr.mapping.map(replaceTo, 1);
+  view.dispatch(tr);
+
+  // Leave the document alone rather than replacing an implausible range.
+  if (insertedFrom >= insertedTo || insertedTo > view.state.doc.content.size) {
+    return true;
+  }
+
+  // replace the text with the macro as a separate transaction
+  // so the autoconversion generates 2 undo steps
+  const macroTr = closeHistory(view.state.tr).replaceRangeWith(insertedFrom, insertedTo, macro).scrollIntoView();
+  addLinkMetadata(view.state.selection, macroTr, {
+    inputMethod: INPUT_METHOD.CLIPBOARD,
+    cardAction: 'AUTO_CONVERT'
+  });
+  view.dispatch(macroTr);
+  return true;
+}
+function insertAutoMacro(slice, macro, view, from, to) {
+  return isExperimentEnabled('platform_editor_paste_autoconvert_robustness') ? insertAutoMacroNew(slice, macro, view, from, to) : insertAutoMacroOld(slice, macro, view, from, to);
+}
+
+/**
+ * Locates the range currently occupied by a link that we pasted earlier.
+ *
+ * Positions recorded before an async gap can drift or be invalidated entirely by
+ * concurrent edits, collaborative changes and `appendTransaction` hooks, so the
+ * recorded range is verified against the document before it is used. If it no longer
+ * holds the pasted link the link is re-located by href, preferring the occurrence
+ * closest to where it was last seen.
+ *
+ * Returns `undefined` when the link cannot be found, so callers can leave the
+ * document alone rather than replacing whatever happens to sit at a stale position.
+ */
+/**
+ * Whether every text node spanning [from, to) carries a `link` mark pointing at `url`,
+ * with no gaps or uncovered portions.
+ */
+function rangeIsExactLinkMark(doc, from, to, url, linkMarkType) {
+  let matches = true;
+  let coveredTo = from;
+  doc.nodesBetween(from, to, (node, pos) => {
+    if (!matches || pos >= to) {
+      return false;
+    }
+    if (!node.isLeaf) {
+      // A container node — e.g. the paragraph the link sits in. `nodesBetween` visits
+      // these on the way down to the text node(s) we actually care about; keep
+      // descending into it rather than treating it as a mismatch.
+      return true;
+    }
+    if (!node.isText) {
+      // A non-text leaf (e.g. an inline card) cannot carry the link mark.
+      matches = false;
+      return false;
+    }
+    const linkMark = linkMarkType.isInSet(node.marks);
+    if (!linkMark || linkMark.attrs.href !== url) {
+      matches = false;
+      return false;
+    }
+    coveredTo = Math.min(pos + node.nodeSize, to);
+    return true;
+  });
+  return matches && coveredTo === to;
+}
+
+/**
+ * `from`/`to` are not a one-off snapshot: they come from `pastedMacroPositions`, which the
+ * paste plugin's `mapping` hook (`plugin-factory.ts`) maps through every transaction
+ * applied while the smart link request is in flight, via `tr.mapping.map(position)`. So
+ * this covers every edit ProseMirror can express as a position mapping — typing,
+ * deleting, or moving content elsewhere in the same edit all keep `from`/`to` pointing at
+ * the same logical span.
+ *
+ * It stops covering that span only when the span itself no longer represents our pasted
+ * link — the link was unlinked, or its content was replaced outright. Deliberately no
+ * fallback search for "the nearest link with the same href" is done: with multiple links
+ * to the same URL in the document, a proximity search cannot tell which one we pasted, so
+ * it risks silently replacing an occurrence we were never asked to touch, and it requires
+ * an O(doc size) scan on every fallback to do it. Leaving the tracked link as a link is
+ * the safe outcome here, and it's what happens when this function returns `undefined`.
+ */
+function findPastedLinkRange(state, url, from, to) {
+  const {
+    doc,
+    schema
+  } = state;
+  const linkMarkType = schema.marks.link;
+  const docSize = doc.content.size;
+  if (!linkMarkType || typeof from !== 'number' || typeof to !== 'number' || from < 0 || from >= to || to > docSize) {
+    return undefined;
+  }
+
+  // Text equality alone is not enough: if the link was unlinked (mark removed) while
+  // the smart link request was in flight, the text can still read as the URL even
+  // though it is no longer a link, and replacing it would destroy content that is no
+  // longer ours to replace.
+  if (doc.textBetween(from, to) === url && rangeIsExactLinkMark(doc, from, to, url, linkMarkType)) {
+    return {
+      from,
+      to
+    };
+  }
+  return undefined;
+}
+
+/**
+ * Swaps a link that was already pasted into the document for its macro equivalent.
+ *
+ * Used when smart links could not resolve the URL, so the macro autoconversion is the
+ * fallback. Does nothing if the link can no longer be found — for example because a
+ * smart card has already replaced it — which is preferable to replacing unrelated
+ * content at a stale position.
+ */
+function replacePastedLinkWithMacro(view, macro, url, from, to, editorAnalyticsAPI) {
+  const range = findPastedLinkRange(view.state, url, from, to);
+  if (!range) {
+    // Metric for how often the tracked pasted link could no longer be found once the
+    // smart link request settled, so the assumption that this is rare is measurable
+    // rather than assumed.
+    editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.fireAnalyticsEvent({
+      action: ACTION.ERRORED,
+      actionSubject: ACTION_SUBJECT.SMART_LINK,
+      eventType: EVENT_TYPE.OPERATIONAL,
+      attributes: {
+        error: 'macro-auto-convert-pasted-link-not-found'
+      }
+    });
+    return false;
+  }
+  const macroTr = closeHistory(view.state.tr).replaceRangeWith(range.from, range.to, macro).scrollIntoView();
+  addLinkMetadata(view.state.selection, macroTr, {
+    inputMethod: INPUT_METHOD.CLIPBOARD,
+    cardAction: 'AUTO_CONVERT'
+  });
+  view.dispatch(macroTr);
+  return true;
+}
+export function handleMacroAutoConvert(text, slice, queueCardsFromChangedTr, runMacroAutoConvert, cardsOptions, extensionAutoConverter, editorAnalyticsAPI) {
   return (state, dispatch, view) => {
     let macro = null;
 
@@ -663,11 +828,42 @@ export function handleMacroAutoConvert(text, slice, queueCardsFromChangedTr, run
         if (!view) {
           throw new Error('View is missing');
         }
+        const autoConvertMacro = macro;
 
         // eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
         const trackingId = uuid();
         const trackingFrom = `handleMacroAutoConvert-from-${trackingId}`;
         const trackingTo = `handleMacroAutoConvert-to-${trackingId}`;
+        if (isExperimentEnabled('platform_editor_paste_autoconvert_robustness')) {
+          // Insert the pasted content straight away. The smart link provider is only
+          // consulted to decide whether the inserted link should later be swapped for
+          // a macro, so it does not need to gate the insert — otherwise every
+          // autoconvertible paste appears to do nothing until a network round trip
+          // completes.
+          let insertedRange;
+          handleMarkdownWithInsertedRange(slice, queueCardsFromChangedTr, range => {
+            insertedRange = range;
+          })(state, dispatch);
+          if (!insertedRange) {
+            return true;
+          }
+          startTrackingPastedMacroPositions({
+            [trackingFrom]: insertedRange.from,
+            [trackingTo]: insertedRange.to
+          })(view.state, dispatch);
+          getSmartLinkAdf(text, 'inline', cardsOptions).catch(() => {
+            // Smart links could not resolve the URL, so fall back to the macro.
+            // we use view.state rather than state because state becomes a stale
+            // state reference after getSmartLinkAdf's async work
+            const {
+              pastedMacroPositions
+            } = getPastePluginState(view.state);
+            replacePastedLinkWithMacro(view, autoConvertMacro, text, pastedMacroPositions[trackingFrom], pastedMacroPositions[trackingTo], editorAnalyticsAPI);
+          }).finally(() => {
+            stopTrackingPastedMacroPositions([trackingFrom, trackingTo])(view.state, dispatch);
+          });
+          return true;
+        }
         startTrackingPastedMacroPositions({
           [trackingFrom]: state.selection.from,
           [trackingTo]: state.selection.to
@@ -984,6 +1180,36 @@ function resolveParagraphMarks(marks, destinationBlockMarkAttrs, shouldNormalize
   }
   return marks;
 }
+
+/**
+ * Variant of `handleMarkdown` used by macro auto-conversion behind
+ * `platform_editor_paste_autoconvert_robustness`.
+ *
+ * Differs in two ways: the inserted range is derived from the steps that were applied
+ * rather than from `markdownSlice.size`, which does not account for ProseMirror's fitting
+ * behaviour; and that range is reported back through `onInsert` so the caller can track
+ * the inserted link across the async gap before deciding whether to swap it for a macro.
+ */
+function handleMarkdownWithInsertedRange(markdownSlice, queueCardsFromChangedTr, onInsert) {
+  return (state, dispatch) => {
+    const tr = closeHistory(state.tr);
+    const replaceFrom = tr.selection.from;
+    const replaceTo = tr.selection.to;
+    tr.replaceSelection(markdownSlice);
+    const insertedFrom = tr.mapping.map(replaceFrom, -1);
+    const insertedTo = tr.mapping.map(replaceTo, 1);
+    tr.setSelection(TextSelection.near(tr.doc.resolve(Math.min(insertedTo, tr.doc.content.size)), -1));
+    queueCardsFromChangedTr === null || queueCardsFromChangedTr === void 0 ? void 0 : queueCardsFromChangedTr(state, tr, INPUT_METHOD.CLIPBOARD);
+    if (dispatch) {
+      dispatch(tr.scrollIntoView());
+      onInsert({
+        from: insertedFrom,
+        to: insertedTo
+      });
+    }
+    return true;
+  };
+}
 export function handleParagraphBlockMarks(state, slice) {
   var _findParentNodeOfType2;
   if (slice.content.size === 0) {

package/dist/esm/pm-plugins/main.js

@@ -409,7 +409,7 @@ export function createPlugin(schema, dispatchAnalyticsEvent, dispatch, featureFl
             }
 
             // run macro autoconvert prior to other conversions
-            if (handleMacroAutoConvert(text, markdownSlice, pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$c = pluginInjectionApi.card) === null || _pluginInjectionApi$c === void 0 || (_pluginInjectionApi$c = _pluginInjectionApi$c.actions) === null || _pluginInjectionApi$c === void 0 ? void 0 : _pluginInjectionApi$c.queueCardsFromChangedTr, pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$e = pluginInjectionApi.extension) === null || _pluginInjectionApi$e === void 0 || (_pluginInjectionApi$e = _pluginInjectionApi$e.actions) === null || _pluginInjectionApi$e === void 0 ? void 0 : _pluginInjectionApi$e.runMacroAutoConvert, cardOptions, extensionAutoConverter)(state, dispatch, view)) {
+            if (handleMacroAutoConvert(text, markdownSlice, pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$c = pluginInjectionApi.card) === null || _pluginInjectionApi$c === void 0 || (_pluginInjectionApi$c = _pluginInjectionApi$c.actions) === null || _pluginInjectionApi$c === void 0 ? void 0 : _pluginInjectionApi$c.queueCardsFromChangedTr, pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$e = pluginInjectionApi.extension) === null || _pluginInjectionApi$e === void 0 || (_pluginInjectionApi$e = _pluginInjectionApi$e.actions) === null || _pluginInjectionApi$e === void 0 ? void 0 : _pluginInjectionApi$e.runMacroAutoConvert, cardOptions, extensionAutoConverter, editorAnalyticsAPI)(state, dispatch, view)) {
               // TODO: ED-26959 - handleMacroAutoConvert dispatch twice, so we can't use the helper
               sendPasteAnalyticsEvent(editorAnalyticsAPI)(view, event, markdownSlice, {
                 type: PasteTypes.markdown
@@ -507,7 +507,7 @@ export function createPlugin(schema, dispatchAnalyticsEvent, dispatch, featureFl
           }
 
           // run macro autoconvert prior to other conversions
-          if (handleMacroAutoConvert(text, slice, pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$c2 = pluginInjectionApi.card) === null || _pluginInjectionApi$c2 === void 0 || (_pluginInjectionApi$c2 = _pluginInjectionApi$c2.actions) === null || _pluginInjectionApi$c2 === void 0 ? void 0 : _pluginInjectionApi$c2.queueCardsFromChangedTr, pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$e2 = pluginInjectionApi.extension) === null || _pluginInjectionApi$e2 === void 0 || (_pluginInjectionApi$e2 = _pluginInjectionApi$e2.actions) === null || _pluginInjectionApi$e2 === void 0 ? void 0 : _pluginInjectionApi$e2.runMacroAutoConvert, cardOptions, extensionAutoConverter)(state, dispatch, view)) {
+          if (handleMacroAutoConvert(text, slice, pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$c2 = pluginInjectionApi.card) === null || _pluginInjectionApi$c2 === void 0 || (_pluginInjectionApi$c2 = _pluginInjectionApi$c2.actions) === null || _pluginInjectionApi$c2 === void 0 ? void 0 : _pluginInjectionApi$c2.queueCardsFromChangedTr, pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$e2 = pluginInjectionApi.extension) === null || _pluginInjectionApi$e2 === void 0 || (_pluginInjectionApi$e2 = _pluginInjectionApi$e2.actions) === null || _pluginInjectionApi$e2 === void 0 ? void 0 : _pluginInjectionApi$e2.runMacroAutoConvert, cardOptions, extensionAutoConverter, editorAnalyticsAPI)(state, dispatch, view)) {
             // TODO: ED-26959 - handleMacroAutoConvert dispatch twice, so we can't use the helper
             sendPasteAnalyticsEvent(editorAnalyticsAPI)(view, event, slice, {
               type: PasteTypes.richText

package/dist/esm/pm-plugins/util/handlers.js

@@ -10,7 +10,7 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 // eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
 import { v4 as uuid } from 'uuid';
 import { transformContainerNodes } from '@atlaskit/adf-utils/transforms';
-import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { ACTION, ACTION_SUBJECT, EVENT_TYPE, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
 import { addLinkMetadata } from '@atlaskit/editor-common/card';
 import { insideTable } from '@atlaskit/editor-common/core-utils';
 import { getBlockMarkAttrs, getFirstParagraphBlockMarkAttrs, reconcileBlockMarkForContainerAtPos, reconcileBlockMarkForParagraphAtPos, reconcileBlockMarkInRange } from '@atlaskit/editor-common/lists';
@@ -613,7 +613,7 @@ function _getSmartLinkAdf() {
   }));
   return _getSmartLinkAdf.apply(this, arguments);
 }
-function insertAutoMacro(slice, macro, view, from, to) {
+function insertAutoMacroOld(slice, macro, view, from, to) {
   if (view) {
     // insert the text or linkified/md-converted clipboard data
     var selection = view.state.tr.selection;
@@ -640,7 +640,168 @@ function insertAutoMacro(slice, macro, view, from, to) {
   }
   return false;
 }
-export function handleMacroAutoConvert(text, slice, queueCardsFromChangedTr, runMacroAutoConvert, cardsOptions, extensionAutoConverter) {
+
+/**
+ * Replacement for `insertAutoMacroOld` behind
+ * `platform_editor_paste_autoconvert_robustness`.
+ *
+ * Identical in shape, except that the range the macro replaces is derived from the steps
+ * that were actually applied rather than from `slice.size`. `slice.size` is the slice's
+ * own measure and does not account for ProseMirror's fitting behaviour in
+ * `replaceRange`/`replaceSelection`, so the two can disagree — and when they do the macro
+ * is inserted without removing the text it should replace, leaving both the pasted text
+ * and the macro in the document.
+ */
+function insertAutoMacroNew(slice, macro, view, from, to) {
+  if (!view) {
+    return false;
+  }
+  var selection = view.state.selection;
+  var hasExplicitRange = typeof from === 'number' && typeof to === 'number';
+  var replaceFrom = hasExplicitRange ? from : selection.from;
+  var replaceTo = hasExplicitRange ? to : selection.to;
+
+  // insert the text or linkified/md-converted clipboard data
+  var tr = hasExplicitRange ? view.state.tr.replaceRange(replaceFrom, replaceTo, slice) : view.state.tr.replaceSelection(slice);
+  var insertedFrom = tr.mapping.map(replaceFrom, -1);
+  var insertedTo = tr.mapping.map(replaceTo, 1);
+  view.dispatch(tr);
+
+  // Leave the document alone rather than replacing an implausible range.
+  if (insertedFrom >= insertedTo || insertedTo > view.state.doc.content.size) {
+    return true;
+  }
+
+  // replace the text with the macro as a separate transaction
+  // so the autoconversion generates 2 undo steps
+  var macroTr = closeHistory(view.state.tr).replaceRangeWith(insertedFrom, insertedTo, macro).scrollIntoView();
+  addLinkMetadata(view.state.selection, macroTr, {
+    inputMethod: INPUT_METHOD.CLIPBOARD,
+    cardAction: 'AUTO_CONVERT'
+  });
+  view.dispatch(macroTr);
+  return true;
+}
+function insertAutoMacro(slice, macro, view, from, to) {
+  return isExperimentEnabled('platform_editor_paste_autoconvert_robustness') ? insertAutoMacroNew(slice, macro, view, from, to) : insertAutoMacroOld(slice, macro, view, from, to);
+}
+
+/**
+ * Locates the range currently occupied by a link that we pasted earlier.
+ *
+ * Positions recorded before an async gap can drift or be invalidated entirely by
+ * concurrent edits, collaborative changes and `appendTransaction` hooks, so the
+ * recorded range is verified against the document before it is used. If it no longer
+ * holds the pasted link the link is re-located by href, preferring the occurrence
+ * closest to where it was last seen.
+ *
+ * Returns `undefined` when the link cannot be found, so callers can leave the
+ * document alone rather than replacing whatever happens to sit at a stale position.
+ */
+/**
+ * Whether every text node spanning [from, to) carries a `link` mark pointing at `url`,
+ * with no gaps or uncovered portions.
+ */
+function rangeIsExactLinkMark(doc, from, to, url, linkMarkType) {
+  var matches = true;
+  var coveredTo = from;
+  doc.nodesBetween(from, to, function (node, pos) {
+    if (!matches || pos >= to) {
+      return false;
+    }
+    if (!node.isLeaf) {
+      // A container node — e.g. the paragraph the link sits in. `nodesBetween` visits
+      // these on the way down to the text node(s) we actually care about; keep
+      // descending into it rather than treating it as a mismatch.
+      return true;
+    }
+    if (!node.isText) {
+      // A non-text leaf (e.g. an inline card) cannot carry the link mark.
+      matches = false;
+      return false;
+    }
+    var linkMark = linkMarkType.isInSet(node.marks);
+    if (!linkMark || linkMark.attrs.href !== url) {
+      matches = false;
+      return false;
+    }
+    coveredTo = Math.min(pos + node.nodeSize, to);
+    return true;
+  });
+  return matches && coveredTo === to;
+}
+
+/**
+ * `from`/`to` are not a one-off snapshot: they come from `pastedMacroPositions`, which the
+ * paste plugin's `mapping` hook (`plugin-factory.ts`) maps through every transaction
+ * applied while the smart link request is in flight, via `tr.mapping.map(position)`. So
+ * this covers every edit ProseMirror can express as a position mapping — typing,
+ * deleting, or moving content elsewhere in the same edit all keep `from`/`to` pointing at
+ * the same logical span.
+ *
+ * It stops covering that span only when the span itself no longer represents our pasted
+ * link — the link was unlinked, or its content was replaced outright. Deliberately no
+ * fallback search for "the nearest link with the same href" is done: with multiple links
+ * to the same URL in the document, a proximity search cannot tell which one we pasted, so
+ * it risks silently replacing an occurrence we were never asked to touch, and it requires
+ * an O(doc size) scan on every fallback to do it. Leaving the tracked link as a link is
+ * the safe outcome here, and it's what happens when this function returns `undefined`.
+ */
+function findPastedLinkRange(state, url, from, to) {
+  var doc = state.doc,
+    schema = state.schema;
+  var linkMarkType = schema.marks.link;
+  var docSize = doc.content.size;
+  if (!linkMarkType || typeof from !== 'number' || typeof to !== 'number' || from < 0 || from >= to || to > docSize) {
+    return undefined;
+  }
+
+  // Text equality alone is not enough: if the link was unlinked (mark removed) while
+  // the smart link request was in flight, the text can still read as the URL even
+  // though it is no longer a link, and replacing it would destroy content that is no
+  // longer ours to replace.
+  if (doc.textBetween(from, to) === url && rangeIsExactLinkMark(doc, from, to, url, linkMarkType)) {
+    return {
+      from: from,
+      to: to
+    };
+  }
+  return undefined;
+}
+
+/**
+ * Swaps a link that was already pasted into the document for its macro equivalent.
+ *
+ * Used when smart links could not resolve the URL, so the macro autoconversion is the
+ * fallback. Does nothing if the link can no longer be found — for example because a
+ * smart card has already replaced it — which is preferable to replacing unrelated
+ * content at a stale position.
+ */
+function replacePastedLinkWithMacro(view, macro, url, from, to, editorAnalyticsAPI) {
+  var range = findPastedLinkRange(view.state, url, from, to);
+  if (!range) {
+    // Metric for how often the tracked pasted link could no longer be found once the
+    // smart link request settled, so the assumption that this is rare is measurable
+    // rather than assumed.
+    editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.fireAnalyticsEvent({
+      action: ACTION.ERRORED,
+      actionSubject: ACTION_SUBJECT.SMART_LINK,
+      eventType: EVENT_TYPE.OPERATIONAL,
+      attributes: {
+        error: 'macro-auto-convert-pasted-link-not-found'
+      }
+    });
+    return false;
+  }
+  var macroTr = closeHistory(view.state.tr).replaceRangeWith(range.from, range.to, macro).scrollIntoView();
+  addLinkMetadata(view.state.selection, macroTr, {
+    inputMethod: INPUT_METHOD.CLIPBOARD,
+    cardAction: 'AUTO_CONVERT'
+  });
+  view.dispatch(macroTr);
+  return true;
+}
+export function handleMacroAutoConvert(text, slice, queueCardsFromChangedTr, runMacroAutoConvert, cardsOptions, extensionAutoConverter, editorAnalyticsAPI) {
   return function (state, dispatch, view) {
     var macro = null;
 
@@ -668,23 +829,50 @@ export function handleMacroAutoConvert(text, slice, queueCardsFromChangedTr, run
         if (!view) {
           throw new Error('View is missing');
         }
+        var autoConvertMacro = macro;
 
         // eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
         var trackingId = uuid();
         var trackingFrom = "handleMacroAutoConvert-from-".concat(trackingId);
         var trackingTo = "handleMacroAutoConvert-to-".concat(trackingId);
+        if (isExperimentEnabled('platform_editor_paste_autoconvert_robustness')) {
+          // Insert the pasted content straight away. The smart link provider is only
+          // consulted to decide whether the inserted link should later be swapped for
+          // a macro, so it does not need to gate the insert — otherwise every
+          // autoconvertible paste appears to do nothing until a network round trip
+          // completes.
+          var insertedRange;
+          handleMarkdownWithInsertedRange(slice, queueCardsFromChangedTr, function (range) {
+            insertedRange = range;
+          })(state, dispatch);
+          if (!insertedRange) {
+            return true;
+          }
+          startTrackingPastedMacroPositions(_defineProperty(_defineProperty({}, trackingFrom, insertedRange.from), trackingTo, insertedRange.to))(view.state, dispatch);
+          getSmartLinkAdf(text, 'inline', cardsOptions).catch(function () {
+            // Smart links could not resolve the URL, so fall back to the macro.
+            // we use view.state rather than state because state becomes a stale
+            // state reference after getSmartLinkAdf's async work
+            var _getPastePluginState = getPastePluginState(view.state),
+              pastedMacroPositions = _getPastePluginState.pastedMacroPositions;
+            replacePastedLinkWithMacro(view, autoConvertMacro, text, pastedMacroPositions[trackingFrom], pastedMacroPositions[trackingTo], editorAnalyticsAPI);
+          }).finally(function () {
+            stopTrackingPastedMacroPositions([trackingFrom, trackingTo])(view.state, dispatch);
+          });
+          return true;
+        }
         startTrackingPastedMacroPositions(_defineProperty(_defineProperty({}, trackingFrom, state.selection.from), trackingTo, state.selection.to))(state, dispatch);
         getSmartLinkAdf(text, 'inline', cardsOptions).then(function () {
           // we use view.state rather than state because state becomes a stale
           // state reference after getSmartLinkAdf's async work
-          var _getPastePluginState = getPastePluginState(view.state),
-            pastedMacroPositions = _getPastePluginState.pastedMacroPositions;
+          var _getPastePluginState2 = getPastePluginState(view.state),
+            pastedMacroPositions = _getPastePluginState2.pastedMacroPositions;
           if (dispatch) {
             handleMarkdown(slice, queueCardsFromChangedTr, pastedMacroPositions[trackingFrom], pastedMacroPositions[trackingTo])(view.state, dispatch);
           }
         }).catch(function () {
-          var _getPastePluginState2 = getPastePluginState(view.state),
-            pastedMacroPositions = _getPastePluginState2.pastedMacroPositions;
+          var _getPastePluginState3 = getPastePluginState(view.state),
+            pastedMacroPositions = _getPastePluginState3.pastedMacroPositions;
           insertAutoMacro(slice, macro, view, pastedMacroPositions[trackingFrom], pastedMacroPositions[trackingTo]);
         }).finally(function () {
           stopTrackingPastedMacroPositions([trackingFrom, trackingTo])(view.state, dispatch);
@@ -978,6 +1166,36 @@ function resolveParagraphMarks(marks, destinationBlockMarkAttrs, shouldNormalize
   }
   return marks;
 }
+
+/**
+ * Variant of `handleMarkdown` used by macro auto-conversion behind
+ * `platform_editor_paste_autoconvert_robustness`.
+ *
+ * Differs in two ways: the inserted range is derived from the steps that were applied
+ * rather than from `markdownSlice.size`, which does not account for ProseMirror's fitting
+ * behaviour; and that range is reported back through `onInsert` so the caller can track
+ * the inserted link across the async gap before deciding whether to swap it for a macro.
+ */
+function handleMarkdownWithInsertedRange(markdownSlice, queueCardsFromChangedTr, onInsert) {
+  return function (state, dispatch) {
+    var tr = closeHistory(state.tr);
+    var replaceFrom = tr.selection.from;
+    var replaceTo = tr.selection.to;
+    tr.replaceSelection(markdownSlice);
+    var insertedFrom = tr.mapping.map(replaceFrom, -1);
+    var insertedTo = tr.mapping.map(replaceTo, 1);
+    tr.setSelection(TextSelection.near(tr.doc.resolve(Math.min(insertedTo, tr.doc.content.size)), -1));
+    queueCardsFromChangedTr === null || queueCardsFromChangedTr === void 0 || queueCardsFromChangedTr(state, tr, INPUT_METHOD.CLIPBOARD);
+    if (dispatch) {
+      dispatch(tr.scrollIntoView());
+      onInsert({
+        from: insertedFrom,
+        to: insertedTo
+      });
+    }
+    return true;
+  };
+}
 export function handleParagraphBlockMarks(state, slice) {
   var _findParentNodeOfType2;
   if (slice.content.size === 0) {

package/dist/types/pm-plugins/util/handlers.d.ts

@@ -16,7 +16,7 @@ export declare function handlePastePanelOrDecisionContentIntoList(slice: Slice,
 export declare function handlePasteLinkOnSelectedText(slice: Slice): Command;
 export declare function handlePasteAsPlainText(slice: Slice, _event: ClipboardEvent, editorAnalyticsAPI: EditorAnalyticsAPI | undefined): Command;
 export declare function handlePastePreservingMarks(slice: Slice, queueCardsFromChangedTr: QueueCardsFromTransactionAction | undefined): Command;
-export declare function handleMacroAutoConvert(text: string, slice: Slice, queueCardsFromChangedTr: QueueCardsFromTransactionAction | undefined, runMacroAutoConvert: RunMacroAutoConvert | undefined, cardsOptions?: CardOptions, extensionAutoConverter?: ExtensionAutoConvertHandler): Command;
+export declare function handleMacroAutoConvert(text: string, slice: Slice, queueCardsFromChangedTr: QueueCardsFromTransactionAction | undefined, runMacroAutoConvert: RunMacroAutoConvert | undefined, cardsOptions?: CardOptions, extensionAutoConverter?: ExtensionAutoConvertHandler, editorAnalyticsAPI?: EditorAnalyticsAPI): Command;
 export declare function handleCodeBlock(text: string): Command;
 export declare function handleMediaSingle(inputMethod: InputMethodInsertMedia, insertMediaAsMediaSingle: InsertMediaAsMediaSingle | undefined): (slice: Slice) => Command;
 export declare function handleTableContentPasteInBodiedExtension(slice: Slice): Command;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-paste",
-	"version": "18.0.4",
+	"version": "18.0.5",
 	"description": "Paste plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -82,5 +82,11 @@
 		"platform_editor_flexible_list_kill_switch_1": {
 			"type": "boolean"
 		}
+	},
+	"platform-experiments": {
+		"platform_editor_paste_autoconvert_robustness": {
+			"param": "isEnabled",
+			"defaultValue": false
+		}
 	}
 }